def run(fmodel, model, log, params=None): print_statistics.make_header("Fit water hydrogens into residual map", out=log) if (params is None): params = all_master_params().extract() print_statistics.make_sub_header("find peak-candidates", out=log) peaks = find_hydrogen_peaks(fmodel=fmodel, pdb_atoms=model.get_atoms(), params=params, log=log) waters_and_peaks = extract_hoh_peaks( peaks=peaks, pdb_hierarchy=model.get_hierarchy(), pdb_atoms=model.get_atoms(), xray_structure=model.get_xray_structure()) print_statistics.make_sub_header("6D rigid body fit of HOH", out=log) print("Fit quality:", file=log) for water_and_peaks in waters_and_peaks: fit_water(water_and_peaks=water_and_peaks, xray_structure=model.get_xray_structure(), params=params, log=log) # adjust ADP for H # TODO mrt: probably H bfactors should be equal to those # of the bonded atom u_isos = model.get_xray_structure().extract_u_iso_or_u_equiv() u_iso_mean = flex.mean(u_isos) sel_big = u_isos > u_iso_mean * 2 hd_sel = model.get_hd_selection() sel_big.set_selected(~hd_sel, False) model.get_xray_structure().set_u_iso(value=u_iso_mean, selection=sel_big)
def run(fmodel, model, log, params = None): print_statistics.make_header("Fit water hydrogens into residual map", out = log) if(params is None): params = all_master_params().extract() print_statistics.make_sub_header("find peak-candidates", out = log) peaks = find_hydrogen_peaks( fmodel = fmodel, pdb_atoms = model.pdb_atoms, params = params, log = log) waters_and_peaks = extract_hoh_peaks( peaks = peaks, pdb_hierarchy = model.pdb_hierarchy(), pdb_atoms = model.pdb_atoms, xray_structure = model.xray_structure) print_statistics.make_sub_header("6D rigid body fit of HOH", out = log) print >> log, "Fit quality:" for water_and_peaks in waters_and_peaks: fit_water(water_and_peaks = water_and_peaks, xray_structure = model.xray_structure, params = params, log = log) # adjust ADP for H # TODO mrt: probably H bfactors should be equal to those # of the bonded atom u_isos = model.xray_structure.extract_u_iso_or_u_equiv() u_iso_mean = flex.mean(u_isos) sel_big = u_isos > u_iso_mean*2 hd_sel = model.xray_structure.hd_selection() sel_big.set_selected(~hd_sel, False) model.xray_structure.set_u_iso(value = u_iso_mean, selection = sel_big)
def show_comprehensive(self, message = ""): """ ... """ from mmtbx.refinement import print_statistics print_statistics.make_sub_header("X-ray data", out = self.log) if(self.fmodel_x is not None): self.fmodel_xray().info().show_all(header = message, out = self.log) if(self.fmodel_n is not None): print_statistics.make_sub_header("Neutron data", out = self.log) self.fmodel_neutron().info().show_all(header = message, out = self.log)
def show_comprehensive(self, message=""): """ ... """ from mmtbx.refinement import print_statistics print_statistics.make_sub_header("X-ray data", out=self.log) if (self.fmodel_x is not None): self.fmodel_xray().info().show_all(header=message, out=self.log) if (self.fmodel_n is not None): print_statistics.make_sub_header("Neutron data", out=self.log) self.fmodel_neutron().info().show_all(header=message, out=self.log)
def manager(params, target_weights, all_params, macro_cycle, h_params, fmodels, model, out = None, states_collector=None, callback=None): if(out is None): out = sys.stdout if (states_collector is not None) : assert hasattr(states_collector, "add") print_statistics.make_header("simulated annealing refinement", out = out) model.set_refine_individual_sites() fmodel = fmodels.fmodel_xray() # XXX use only xray data fmodel.xray_structure = model.xray_structure # XXX use only xray data if (params.max_number_of_iterations >= 0): print_statistics.make_sub_header( "lbfgs minimization: before simulated annealing", out = out) is_neutron_scat_table = False if(all_params.main.scattering_table == "neutron"): is_neutron_scat_table = True import scitbx.lbfgs minimized = mmtbx.refinement.minimization.lbfgs( restraints_manager = model.restraints_manager, refine_xyz = True, fmodels = fmodels, is_neutron_scat_table = is_neutron_scat_table, model = model, lbfgs_termination_params = scitbx.lbfgs.termination_parameters( max_iterations = params.max_number_of_iterations), target_weights = target_weights, h_params = h_params, verbose = 0) fmodel.update_xray_structure(xray_structure = model.xray_structure, update_f_calc = True, update_f_mask = True) print_statistics.make_header("simulated annealing", out = out) wx = target_weights.xyz_weights_result.wx * \ target_weights.xyz_weights_result.wx_scale run( params = params, restraints_manager = model.restraints_manager, fmodel = fmodel, wx = wx, wc = target_weights.xyz_weights_result.w, states_collector = states_collector, callback = callback, log = out)
def manager(params, target_weights, all_params, macro_cycle, h_params, fmodels, model, out=None, states_collector=None, callback=None): if (out is None): out = sys.stdout if (states_collector is not None): assert hasattr(states_collector, "add") print_statistics.make_header("simulated annealing refinement", out=out) model.set_refine_individual_sites() fmodel = fmodels.fmodel_xray() # XXX use only xray data fmodel.xray_structure = model.get_xray_structure( ) # XXX use only xray data if (params.max_number_of_iterations >= 0): print_statistics.make_sub_header( "lbfgs minimization: before simulated annealing", out=out) is_neutron_scat_table = False if (all_params.main.scattering_table == "neutron"): is_neutron_scat_table = True import scitbx.lbfgs minimized = mmtbx.refinement.minimization.lbfgs( restraints_manager=model.restraints_manager, refine_xyz=True, fmodels=fmodels, is_neutron_scat_table=is_neutron_scat_table, model=model, lbfgs_termination_params=scitbx.lbfgs.termination_parameters( max_iterations=params.max_number_of_iterations), target_weights=target_weights, h_params=h_params, verbose=0) fmodel.update_xray_structure(xray_structure=model.get_xray_structure(), update_f_calc=True, update_f_mask=True) print_statistics.make_header("simulated annealing", out=out) wx = target_weights.xyz_weights_result.wx * \ target_weights.xyz_weights_result.wx_scale run(params=params, restraints_manager=model.restraints_manager, fmodel=fmodel, wx=wx, wc=target_weights.xyz_weights_result.w, states_collector=states_collector, callback=callback, log=out)
def show_highest_peaks_and_deepest_holes(fmodel, pdb_atoms, map_type, map_cutoff_plus, map_cutoff_minus, log = None): if(log is None): log = sys.stdout print_statistics.make_header( "residual map %s: highest peaks and deepst holes"%map_type, out = log) fp_params = master_params.extract() fp_params.map_next_to_model.min_model_peak_dist = 0.7 fp_params.map_next_to_model.min_peak_peak_dist = 0.7 fp_params.peak_search.min_cross_distance = 0.7 fp_params.map_next_to_model.use_hydrogens = True for par in [(map_cutoff_plus,"peaks"), (map_cutoff_minus,"holes")]: print_statistics.make_sub_header(par[1], out = log) result = manager(fmodel = fmodel, map_type = "mFobs-DFmodel", map_cutoff = par[0], params = fp_params, log = log) result.peaks_mapped() result.show_mapped(pdb_atoms = pdb_atoms)
def show_highest_peaks_and_deepest_holes(fmodel, pdb_atoms, map_type, map_cutoff_plus, map_cutoff_minus, log=None): if (log is None): log = sys.stdout print_statistics.make_header( "residual map %s: highest peaks and deepst holes" % map_type, out=log) fp_params = master_params.extract() fp_params.map_next_to_model.min_model_peak_dist = 0.7 fp_params.map_next_to_model.min_peak_peak_dist = 0.7 fp_params.peak_search.min_cross_distance = 0.7 fp_params.map_next_to_model.use_hydrogens = True for par in [(map_cutoff_plus, "peaks"), (map_cutoff_minus, "holes")]: print_statistics.make_sub_header(par[1], out=log) result = manager(fmodel=fmodel, map_type="mFobs-DFmodel", map_cutoff=par[0], params=fp_params, log=log) result.peaks_mapped() result.show_mapped(pdb_atoms=pdb_atoms)
def find_tls(params, pdb_hierarchy, xray_structure, return_as_list=False, ignore_pdb_header_groups=False, out=None): """ !!! WARNING! incoming xray_structure here gets converted to isotropic B-factors IN PLACE. """ if (out is None): out = sys.stdout print_statistics.make_header("Analyzing inputs", out=out) if (params.random_seed is None): params.random_seed = flex.get_random_seed() random.seed(params.random_seed) flex.set_random_seed(params.random_seed) xray_structure.convert_to_isotropic() sites_cart = xray_structure.sites_cart() u_cart = None u_iso = xray_structure.extract_u_iso_or_u_equiv() #*adptbx.u_as_b(1.) # ? bad_i_seqs = check_adp(u_iso=u_iso, out=out) if (bad_i_seqs is not None): atoms = pdb_hierarchy.atoms() bad_atom_strings = [] for i_seq in bad_i_seqs[:10]: atom_str = atoms[i_seq].format_atom_record() bad_atom_strings.append(atom_str) if (len(bad_i_seqs) > 10): bad_atom_strings.append("... (remaining %d not shown)" % (len(bad_i_seqs) - 10)) raise Sorry( ("%d atoms in the model contain isotropic B-factors <= 0:\n" + "\n".join(bad_atom_strings)) % (len(bad_i_seqs))) # ssm = mmtbx.secondary_structure.manager(pdb_hierarchy=pdb_hierarchy, sec_str_from_pdb_file=None, params=None, log=out) alpha_h_selection = ssm.helix_selection() secondary_structure_selection = ssm.helix_selection() | \ ssm.beta_selection() | ssm.base_pair_selection() if (u_cart is not None): assert secondary_structure_selection.size() == u_cart.size() else: assert secondary_structure_selection.size() == u_iso.size() ssm.show_summary(log=out) chains_and_residue_selections, secondary_structure_selection = chains_and_atoms( pdb_hierarchy=pdb_hierarchy, secondary_structure_selection=secondary_structure_selection, out=out) chains_and_permutations = [] chains_and_atom_selection_strings = [] print_statistics.make_header("Processing chains", out=out) if (params.nproc is None): params.nproc = 1 for crs in chains_and_residue_selections: print_statistics.make_sub_header("Processing chain '%s'" % crs[0], out=out) chain_selection = chain_selection_from_residues(crs[1]) groups, perms = get_model_partitioning( residues=crs[1], secondary_structure_selection=secondary_structure_selection, out=out) # if (len(perms) == 1): print(" Whole chain is considered as one TLS group.", file=out) chains_and_atom_selection_strings.append([ crs[0], permutations_as_atom_selection_string(groups, perms[0]) ]) else: print(" Fitting TLS matrices...", file=out) dic = {} target_best = 1.e+9 if (params.nproc is Auto) or (params.nproc > 1): process_perms = analyze_permutations(groups=groups, sites_cart=sites_cart, u_cart=u_cart, u_iso=u_iso) from libtbx import easy_mp stdout_and_targets = easy_mp.pool_map( processes=params.nproc, fixed_func=process_perms, args=perms, chunksize=100, func_wrapper="buffer_stdout_stderr") targets = [t for so, t in stdout_and_targets] for (perm, target) in zip(perms, targets): dic.setdefault(len(perm), []).append([target, perm]) else: for i_perm, perm in enumerate(perms): if i_perm % 500 == 0: print(" ...perm %d of %d" % (i_perm, len(perms)), file=out) selections = tls_group_selections(groups, perm) target = 0 for selection in selections: mo = tls_refinery(u_cart=u_cart, u_iso=u_iso, sites_cart=sites_cart, selection=selection) target += mo.f dic.setdefault(len(perm), []).append([target, perm]) #print " perm %d of %d: target=%8.3f (TLS groups: %s), permutation:"%( # i_perm, len(perms),target,len(perm)),perm print(" Best fits:", file=out) print(" No. of Targets", file=out) print(" groups best rand.pick diff. score permutation", file=out) score_best = -1.e+9 perm_choice = None for k, v in six.iteritems(dic): t_best = v[0][0] perm_best = v[0][1] for v_ in v: if (v_[0] < t_best): t_best = v_[0] perm_best = v_[1] if (u_cart is not None): u_cart_ = u_cart.select(chain_selection) else: u_cart_ = None if (u_iso is not None): u_iso_ = u_iso.select(chain_selection) else: u_iso_ = None r = tls_refinery_random_groups( u_cart=u_cart_, u_iso=u_iso_, sites_cart=sites_cart.select(chain_selection), n_groups=k) score = (r - t_best) / (r + t_best) * 100. print(" %3d %6.3f %6.3f %6.2f %6.3f" % (k, t_best, r, r - t_best, score), perm_best, file=out) if (score > score_best): score_best = score perm_choice = perm_best[:] # chains_and_permutations.append([crs[0], perm_choice]) chains_and_atom_selection_strings.append([ crs[0], permutations_as_atom_selection_string(groups, perm_choice) ]) # print_statistics.make_header("SUMMARY", out=out) #print "Optimal TLS groups:" #for chain_and_permutation in chains_and_permutations: # print chain_and_permutation #print print("TLS atom selections for phenix.refine:", file=out) groups_out = StringIO() selection_strings = [] print("refinement.refine.adp {", file=groups_out) for r in chains_and_atom_selection_strings: prefix = "chain '%s'" % r[0] if (len(r[1]) > 0 and len(r[1:]) > 0): prefix += " and " for r_ in r[1:]: for r__ in r_: if (len(r__) > 0): group_selection = prefix + "(%s)" % r__ print(" tls = \"%s\"" % group_selection, file=groups_out) selection_strings.append("%s" % group_selection) else: print(" tls = \"%s\"" % prefix, file=groups_out) selection_strings.append("%s" % prefix) print("}", file=groups_out) print(groups_out.getvalue(), file=out) print(file=out) #XXX if 0: merge_groups_by_connectivity(pdb_hierarchy=pdb_hierarchy, xray_structure=xray_structure, selection_strings=selection_strings) #XXX if (len(selection_strings) > 0): total_target = total_score(pdb_hierarchy=pdb_hierarchy, sites_cart=sites_cart, u_iso=u_iso, selection_strings=selection_strings) print( "Overall best total target for automatically found groups: %10.1f" % total_target, file=out) print(file=out) if (return_as_list): return selection_strings else: return groups_out.getvalue()
def __init__( self, fmodels, model, all_params, group_adp_selections = None, group_adp_selections_h = None, group_adp_params = None, tls_selections = None, tls_params = tls_master_params.extract(), individual_adp_params = individual_adp_master_params.extract(), adp_restraints_params = adp_restraints_master_params.extract(), refine_adp_individual = None, refine_adp_group = None, refine_tls = None, tan_b_iso_max = None, restraints_manager = None, target_weights = None, macro_cycle = None, log = None, h_params = None, nproc = None): global time_adp_refinement_py if(group_adp_params is None): group_adp_params = group_adp_master_params.extract() scatterers = fmodels.fmodel_xray().xray_structure.scatterers() timer = user_plus_sys_time() if(log is None): log = sys.stdout tan_u_iso = False param = 0 if(tan_b_iso_max > 0.0): tan_u_iso = True param = int(tan_b_iso_max) if(macro_cycle == 1): offset = True else: offset = False if(refine_tls): print_statistics.make_sub_header(text = "TLS refinement", out = log) tls_sel_st = flex.size_t() for ts in tls_selections: tls_sel_st.extend(ts) tls_sel_bool = flex.bool(scatterers.size(), flex.size_t(tls_sel_st)) ### totally ad hoc fix tmp_site_t = flex.size_t() for gs in group_adp_selections: for gs_ in gs: tmp_site_t.append(gs_) ### if(macro_cycle == 1 or tmp_site_t.size() != scatterers.size()): gbr_selections = [] for s in tls_selections: gbr_selections.append(s) else: gbr_selections = [] for gs in group_adp_selections: gbr_selection = flex.size_t() for gs_ in gs: if(tls_sel_bool[gs_]): gbr_selection.append(gs_) if(gbr_selection.size() > 0): gbr_selections.append(gbr_selection) gbr_selections_one_arr = flex.size_t() for gbs in gbr_selections: gbr_selections_one_arr.extend(gbs) scatterers = fmodels.fmodel_xray().xray_structure.scatterers() for gbr_selection in gbr_selections_one_arr: scatterers[gbr_selection].flags.set_use_u_iso(True) group_b_manager = mmtbx.refinement.group.manager( fmodel = fmodels.fmodel_xray(), selections = gbr_selections, convergence_test = group_adp_params.convergence_test, max_number_of_iterations = 50, number_of_macro_cycles = 1, refine_adp = True, use_restraints = False, #XXX do not use in TLS refinement for now log = log) scatterers = fmodels.fmodel_xray().xray_structure.scatterers() for tls_selection_ in tls_selections: for tls_selection__ in tls_selection_: scatterers[tls_selection__].flags.set_use_u_aniso(True) model.show_groups(tls = True, out = log) current_target_name = fmodels.fmodel_xray().target_name fmodels.fmodel_xray().update(target_name = "ls_wunit_k1") tools.split_u(fmodels.fmodel_xray().xray_structure, tls_selections, offset) self.tls_refinement_manager = tools.tls_refinement( fmodel = fmodels.fmodel_xray(), model = model, selections = tls_selections, selections_1d = tls_sel_st, refine_T = tls_params.refine_T, refine_L = tls_params.refine_L, refine_S = tls_params.refine_S, number_of_macro_cycles = tls_params.number_of_macro_cycles, max_number_of_iterations = tls_params.max_number_of_iterations, start_tls_value = tls_params.start_tls_value, run_finite_differences_test = tls_params.run_finite_differences_test, eps = tls_params.eps, out = log, macro_cycle = macro_cycle, verbose = tls_params.verbose) fmodels.fmodel_xray().update(target_name = current_target_name) fmodels.update_xray_structure( xray_structure = self.tls_refinement_manager.fmodel.xray_structure, update_f_calc = True) model.set_xray_structure(fmodels.fmodel_xray().xray_structure) if(refine_adp_individual): refine_adp( model = model, fmodels = fmodels, target_weights = target_weights, individual_adp_params = individual_adp_params, adp_restraints_params = adp_restraints_params, h_params = h_params, log = log, all_params = all_params, nproc = nproc) if(refine_adp_group): print_statistics.make_sub_header( text= "group isotropic ADP refinement", out = log) group_b_manager = mmtbx.refinement.group.manager( fmodel = fmodels.fmodel_xray(), selections = group_adp_selections, convergence_test = group_adp_params.convergence_test, max_number_of_iterations = group_adp_params.max_number_of_iterations, number_of_macro_cycles = group_adp_params.number_of_macro_cycles, run_finite_differences_test = group_adp_params.run_finite_differences_test, use_restraints = group_adp_params.use_restraints, restraints_weight = group_adp_params.restraints_weight, refine_adp = True, log = log) time_adp_refinement_py += timer.elapsed()
def __init__( self, model, fmodels, target_weights, individual_adp_params, adp_restraints_params, h_params, log, all_params, nproc=None): adopt_init_args(self, locals()) d_min = fmodels.fmodel_xray().f_obs().d_min() # initialize with defaults... if(target_weights is not None): import mmtbx.refinement.weights_params wcp = mmtbx.refinement.weights_params.tw_customizations_params.extract() for w_s_c in wcp.weight_selection_criteria: if(d_min >= w_s_c.d_min and d_min < w_s_c.d_max): r_free_range_width = w_s_c.r_free_range_width r_free_r_work_gap = w_s_c.r_free_minus_r_work mean_diff_b_iso_bonded_fraction = w_s_c.mean_diff_b_iso_bonded_fraction min_diff_b_iso_bonded = w_s_c.min_diff_b_iso_bonded break # ...then customize wsc = all_params.target_weights.weight_selection_criteria if(wsc.r_free_minus_r_work is not None): r_free_r_work_gap = wsc.r_free_minus_r_work if(wsc.r_free_range_width is not None): r_free_range_width = wsc.r_free_range_width if(wsc.mean_diff_b_iso_bonded_fraction is not None): mean_diff_b_iso_bonded_fraction = wsc.mean_diff_b_iso_bonded_fraction if(wsc.min_diff_b_iso_bonded is not None): min_diff_b_iso_bonded = wsc.min_diff_b_iso_bonded # print_statistics.make_sub_header(text="Individual ADP refinement", out = log) assert fmodels.fmodel_xray().xray_structure is model.get_xray_structure() # fmodels.create_target_functors() assert approx_equal(self.fmodels.fmodel_xray().target_w(), self.fmodels.target_functor_result_xray( compute_gradients=False).target_work()) rw = flex.double() rf = flex.double() rfrw = flex.double() deltab = flex.double() w = flex.double() if(self.target_weights is not None): fmth =" R-FACTORS <Bi-Bj> <B> WEIGHT TARGETS" print(fmth, file=self.log) print(" work free delta data restr", file=self.log) else: print("Unresrained refinement...", file=self.log) self.save_scatterers = self.fmodels.fmodel_xray().xray_structure.\ deep_copy_scatterers().scatterers() if(self.target_weights is not None): default_weight = self.target_weights.adp_weights_result.wx*\ self.target_weights.adp_weights_result.wx_scale if(self.target_weights.twp.optimize_adp_weight): wx_scale = [0.03,0.125,0.5,1.,1.5,2.,2.5,3.,3.5,4.,4.5,5.] trial_weights = list( flex.double(wx_scale)*self.target_weights.adp_weights_result.wx ) self.wx_scale = 1 else: trial_weights = [self.target_weights.adp_weights_result.wx] self.wx_scale = self.target_weights.adp_weights_result.wx_scale else: default_weight = 1 trial_weights = [1] self.wx_scale = 1 self.show(weight=default_weight) trial_results = [] if nproc is None: nproc = all_params.main.nproc parallel = False if (len(trial_weights) > 1) and ((nproc is Auto) or (nproc > 1)): parallel = True from libtbx import easy_mp stdout_and_results = easy_mp.pool_map( processes=nproc, fixed_func=self.try_weight, args=trial_weights, func_wrapper="buffer_stdout_stderr") # XXX safer for phenix GUI trial_results = [ r for so, r in stdout_and_results ] else : for weight in trial_weights: result = self.try_weight(weight, print_stats=True) trial_results.append(result) for result in trial_results : if(result is not None) and (result.r_work is not None): if (parallel): result.show(out=self.log) rw .append(result.r_work) rf .append(result.r_free) rfrw .append(result.r_gap) deltab .append(result.delta_b) w .append(result.weight) # if(len(trial_weights)>1 and rw.size()>0): # filter by rfree-rwork rw,rf,rfrw,deltab,w = self.score(rw=rw,rf=rf,rfrw=rfrw,deltab=deltab,w=w, score_target=rfrw,score_target_value=r_free_r_work_gap, secondary_target=deltab) # filter by rfree rw,rf,rfrw,deltab,w = self.score(rw=rw,rf=rf,rfrw=rfrw,deltab=deltab,w=w, score_target=rf,score_target_value=flex.min(rf)+r_free_range_width) # filter by <Bi-Bj> delta_b_target = max(min_diff_b_iso_bonded, flex.mean(self.fmodels. fmodel_xray().xray_structure.extract_u_iso_or_u_equiv()* adptbx.u_as_b(1))*mean_diff_b_iso_bonded_fraction) print(" max suggested <Bi-Bj> for this run: %7.2f"%delta_b_target, file=log) print(" max allowed Rfree-Rwork gap: %5.1f"%r_free_r_work_gap, file=log) print(" range of equivalent Rfree: %5.1f"%r_free_range_width, file=log) rw,rf,rfrw,deltab,w = self.score(rw=rw,rf=rf,rfrw=rfrw,deltab=deltab,w=w, score_target=deltab,score_target_value=delta_b_target) # select the result with lowest rfree sel = flex.sort_permutation(rf) rw,rf,rfrw,deltab,w= self.select( rw=rw,rf=rf,rfrw=rfrw,deltab=deltab,w=w,sel=sel) # w_best = w[0] rw_best = rw[0] print("Best ADP weight: %8.3f"%w_best, file=self.log) # self.target_weights.adp_weights_result.wx = w_best self.target_weights.adp_weights_result.wx_scale = 1 best_u_star = None best_u_iso = None for result in trial_results : if(abs(result.weight-w_best)<=1.e-8): best_u_star = result.u_star best_u_iso = result.u_iso break if(best_u_iso is None) : # XXX this probably shouldn't happen... self.fmodels.fmodel_xray().xray_structure.replace_scatterers( self.save_scatterers.deep_copy()) else : assert (best_u_star is not None) xrs = self.fmodels.fmodel_xray().xray_structure xrs.set_u_iso(values=best_u_iso) xrs.scatterers().set_u_star(best_u_star) new_u_iso = xrs.scatterers().extract_u_iso() assert (new_u_iso.all_eq(best_u_iso)) self.fmodels.update_xray_structure( xray_structure = self.fmodels.fmodel_xray().xray_structure, update_f_calc = True) print("Accepted refinement result:", file=self.log) # reset alpha/beta parameters - if this is not done, the assertion # below will fail fmodels.create_target_functors() if(self.fmodels.fmodel_neutron() is None): assert approx_equal(self.fmodels.fmodel_xray().r_work()*100, rw_best, eps=0.001) # this needs to be done again again, just in case fmodels.create_target_functors() self.show(weight=w_best) self.fmodels.fmodel_xray().xray_structure.tidy_us() self.fmodels.update_xray_structure( xray_structure = self.fmodels.fmodel_xray().xray_structure, update_f_calc = True) fmodels.create_target_functors() assert approx_equal(self.fmodels.fmodel_xray().target_w(), self.fmodels.target_functor_result_xray( compute_gradients=False).target_work()) self.model.set_xray_structure(self.fmodels.fmodel_xray().xray_structure)
def __init__( self, fmodels, model, all_params, group_adp_selections = None, group_adp_selections_h = None, group_adp_params = group_adp_master_params.extract(), tls_selections = None, nm_selections = None, tls_params = tls_master_params.extract(), nm_params = nm_master_params.extract(), individual_adp_params = individual_adp_master_params.extract(), adp_restraints_params = adp_restraints_master_params.extract(), refine_adp_individual = None, refine_adp_group = None, refine_tls = None, refine_nm = None, tan_b_iso_max = None, restraints_manager = None, target_weights = None, macro_cycle = None, log = None, h_params = None, nproc = None): global time_adp_refinement_py scatterers = fmodels.fmodel_xray().xray_structure.scatterers() timer = user_plus_sys_time() if(log is None): log = sys.stdout tan_u_iso = False param = 0 if(tan_b_iso_max > 0.0): tan_u_iso = True param = int(tan_b_iso_max) if(macro_cycle == 1): offset = True else: offset = False if(refine_tls): print_statistics.make_sub_header(text = "TLS refinement", out = log) tls_sel_st = flex.size_t() for ts in tls_selections: tls_sel_st.extend(ts) tls_sel_bool = flex.bool(scatterers.size(), flex.size_t(tls_sel_st)) ### totally ad hoc fix tmp_site_t = flex.size_t() for gs in group_adp_selections: for gs_ in gs: tmp_site_t.append(gs_) ### if(macro_cycle == 1 or tmp_site_t.size() != scatterers.size()): gbr_selections = [] for s in tls_selections: gbr_selections.append(s) else: gbr_selections = [] for gs in group_adp_selections: gbr_selection = flex.size_t() for gs_ in gs: if(tls_sel_bool[gs_]): gbr_selection.append(gs_) if(gbr_selection.size() > 0): gbr_selections.append(gbr_selection) gbr_selections_one_arr = flex.size_t() for gbs in gbr_selections: gbr_selections_one_arr.extend(gbs) scatterers = fmodels.fmodel_xray().xray_structure.scatterers() for gbr_selection in gbr_selections_one_arr: scatterers[gbr_selection].flags.set_use_u_iso(True) group_b_manager = mmtbx.refinement.group.manager( fmodel = fmodels.fmodel_xray(), selections = gbr_selections, convergence_test = group_adp_params.convergence_test, max_number_of_iterations = 50, number_of_macro_cycles = 1, refine_adp = True, log = log) scatterers = fmodels.fmodel_xray().xray_structure.scatterers() for tls_selection_ in tls_selections: for tls_selection__ in tls_selection_: scatterers[tls_selection__].flags.set_use_u_aniso(True) model.show_groups(tls = True, out = log) current_target_name = fmodels.fmodel_xray().target_name fmodels.fmodel_xray().update(target_name = "ls_wunit_k1") tools.split_u(fmodels.fmodel_xray().xray_structure, tls_selections, offset) self.tls_refinement_manager = tools.tls_refinement( fmodel = fmodels.fmodel_xray(), model = model, selections = tls_selections, selections_1d = tls_sel_st, refine_T = tls_params.refine_T, refine_L = tls_params.refine_L, refine_S = tls_params.refine_S, number_of_macro_cycles = tls_params.number_of_macro_cycles, max_number_of_iterations = tls_params.max_number_of_iterations, start_tls_value = tls_params.start_tls_value, run_finite_differences_test = tls_params.run_finite_differences_test, eps = tls_params.eps, out = log, macro_cycle = macro_cycle, verbose = tls_params.verbose) fmodels.fmodel_xray().update(target_name = current_target_name) fmodels.update_xray_structure( xray_structure = self.tls_refinement_manager.fmodel.xray_structure, update_f_calc = True) model.xray_structure = fmodels.fmodel_xray().xray_structure if(refine_nm): print_statistics.make_sub_header(text = "NM refinement", out = log) nm_sel_st = flex.size_t() for ns in nm_selections: nm_sel_st.extend(ns) scatterers = fmodels.fmodel_xray().xray_structure.scatterers() for nm_selection_ in nm_selections: for nm_selection__ in nm_selection_: scatterers[nm_selection__].flags.set_use_u_aniso(True) model.show_groups(nm = True, out = log) current_target_name = fmodels.fmodel_xray().target_name # fmodels.fmodel_xray().update(target_name = "ls_wunit_k1") # tools.split_u(fmodels.fmodel_xray().xray_structure, tls_selections, offset) self.nm_refinement_manager = nmtools.nm_refinement( fmodel = fmodels.fmodel_xray(), model = model, selections = nm_selections, selections_1d = nm_sel_st, n_modes = nm_params.n_modes, number_of_macro_cycles = nm_params.number_of_macro_cycles, max_number_of_iterations = nm_params.max_number_of_iterations, weight_nmre = nm_params.weight_nmre, evecin = nm_params.evecin, evalin = nm_params.evalin, nm_params_filename = nm_params.nm_params_filename, zero_mode_flag = nm_params.zero_mode_flag, zero_mode_input_flag = nm_params.zero_mode_input_flag, start_xs_value = nm_params.start_xs_value, run_finite_differences_test = nm_params.run_finite_differences_test, eps = nm_params.eps, out = log, macro_cycle = macro_cycle, verbose = nm_params.verbose) fmodels.fmodel_xray().update(target_name = current_target_name) fmodels.update_xray_structure( xray_structure = self.nm_refinement_manager.fmodel.xray_structure, update_f_calc = True) model.xray_structure = fmodels.fmodel_xray().xray_structure if(refine_adp_individual): refine_adp( model = model, fmodels = fmodels, target_weights = target_weights, individual_adp_params = individual_adp_params, adp_restraints_params = adp_restraints_params, h_params = h_params, log = log, all_params = all_params, nproc = nproc) if(refine_adp_group): print_statistics.make_sub_header(text= "group isotropic ADP refinement", out = log) group_b_manager = mmtbx.refinement.group.manager( fmodel = fmodels.fmodel_xray(), selections = group_adp_selections, convergence_test = group_adp_params.convergence_test, max_number_of_iterations = group_adp_params.max_number_of_iterations, number_of_macro_cycles = group_adp_params.number_of_macro_cycles, run_finite_differences_test = group_adp_params.run_finite_differences_test, refine_adp = True, log = log) time_adp_refinement_py += timer.elapsed()
def run(args, crystal_symmetry=None, ncs_object=None, pdb_hierarchy=None, map_data=None, lower_bounds=None, upper_bounds=None, write_output_files=True, log=None): h = "phenix.map_box: extract box with model and map around selected atoms" if (log is None): log = sys.stdout print_statistics.make_header(h, out=log) default_message = """\ %s. Usage: phenix.map_box model.pdb map_coefficients.mtz selection="chain A and resseq 1:10" or phenix.map_box map.ccp4 density_select=True Parameters:""" % h if (len(args) == 0 and not pdb_hierarchy): print default_message master_phil.show(prefix=" ") return inputs = mmtbx.utils.process_command_line_args(args=args, cmd_cs=crystal_symmetry, master_params=master_phil) params = inputs.params.extract() master_phil.format(python_object=params).show(out=log) # Overwrite params with parameters in call if available if lower_bounds: params.lower_bounds = lower_bounds if upper_bounds: params.upper_bounds = upper_bounds # PDB file if params.pdb_file and not inputs.pdb_file_names and not pdb_hierarchy: inputs.pdb_file_names = [params.pdb_file] if (len(inputs.pdb_file_names) != 1 and not params.density_select and not pdb_hierarchy and not params.keep_map_size and not params.upper_bounds and not params.extract_unique): raise Sorry("PDB file is needed unless extract_unique, " + "density_select, keep_map_size \nor bounds are set .") if (len(inputs.pdb_file_names)!=1 and not pdb_hierarchy and \ (params.mask_atoms or params.soft_mask )): raise Sorry("PDB file is needed for mask_atoms or soft_mask") if (params.density_select and params.keep_map_size): raise Sorry("Cannot set both density_select and keep_map_size") if (params.density_select and params.upper_bounds): raise Sorry("Cannot set both density_select and bounds") if (params.keep_map_size and params.upper_bounds): raise Sorry("Cannot set both keep_map_size and bounds") if (params.upper_bounds and not params.lower_bounds): raise Sorry("Please set lower_bounds if you set upper_bounds") if (params.extract_unique and not params.resolution): raise Sorry("Please set resolution for extract_unique") print_statistics.make_sub_header("pdb model", out=log) if len(inputs.pdb_file_names) > 0: pdb_inp = iotbx.pdb.input(file_name=inputs.pdb_file_names[0]) pdb_hierarchy = pdb_inp.construct_hierarchy() if pdb_hierarchy: pdb_atoms = pdb_hierarchy.atoms() pdb_atoms.reset_i_seq() else: pdb_hierarchy = None # Map or map coefficients map_coeff = None if (not map_data): # read first mtz file if ((len(inputs.reflection_file_names) > 0) or (params.map_coefficients_file is not None)): # file in phil takes precedent if (params.map_coefficients_file is not None): if (len(inputs.reflection_file_names) == 0): inputs.reflection_file_names.append( params.map_coefficients_file) else: inputs.reflection_file_names[ 0] = params.map_coefficients_file map_coeff = reflection_file_utils.extract_miller_array_from_file( file_name=inputs.reflection_file_names[0], label=params.label, type="complex", log=log) if not crystal_symmetry: crystal_symmetry = map_coeff.crystal_symmetry() fft_map = map_coeff.fft_map( resolution_factor=params.resolution_factor) fft_map.apply_sigma_scaling() map_data = fft_map.real_map_unpadded() map_or_map_coeffs_prefix = os.path.basename( inputs.reflection_file_names[0][:-4]) # or read CCP4 map elif ((inputs.ccp4_map is not None) or (params.ccp4_map_file is not None)): if (params.ccp4_map_file is not None): af = any_file(params.ccp4_map_file) if (af.file_type == 'ccp4_map'): inputs.ccp4_map = af.file_content inputs.ccp4_map_file_name = params.ccp4_map_file print_statistics.make_sub_header("CCP4 map", out=log) ccp4_map = inputs.ccp4_map ccp4_map.show_summary(prefix=" ", out=log) if not crystal_symmetry: crystal_symmetry = ccp4_map.crystal_symmetry() map_data = ccp4_map.data #map_data() if inputs.ccp4_map_file_name.endswith(".ccp4"): map_or_map_coeffs_prefix = os.path.basename( inputs.ccp4_map_file_name[:-5]) else: map_or_map_coeffs_prefix = os.path.basename( inputs.ccp4_map_file_name[:-4]) else: # have map_data map_or_map_coeffs_prefix = None if crystal_symmetry and not inputs.crystal_symmetry: inputs.crystal_symmetry = crystal_symmetry # final check that map_data exists if (map_data is None): raise Sorry("Map or map coefficients file is needed.") if len(inputs.pdb_file_names) > 0: output_prefix = os.path.basename(inputs.pdb_file_names[0])[:-4] else: output_prefix = map_or_map_coeffs_prefix if not pdb_hierarchy: # get an empty hierarchy from cctbx.array_family import flex pdb_hierarchy = iotbx.pdb.input( source_info='', lines=flex.split_lines('')).construct_hierarchy() xray_structure = pdb_hierarchy.extract_xray_structure( crystal_symmetry=inputs.crystal_symmetry) xray_structure.show_summary(f=log) # selection = pdb_hierarchy.atom_selection_cache().selection( string=params.selection) if selection.size(): print_statistics.make_sub_header("atom selection", out=log) print >> log, "Selection string: selection='%s'" % params.selection print >> log, \ " selects %d atoms from total %d atoms."%(selection.count(True), selection.size()) sites_cart_all = xray_structure.sites_cart() sites_cart = sites_cart_all.select(selection) selection = xray_structure.selection_within(radius=params.selection_radius, selection=selection) if not ncs_object: from mmtbx.ncs.ncs import ncs ncs_object = ncs() if params.symmetry_file: ncs_object.read_ncs(params.symmetry_file, log=log) print >> log, "Total of %s operators read" % ( ncs_object.max_operators()) if not ncs_object or ncs_object.max_operators() < 1: print >> log, "No symmetry available" if ncs_object: n_ops = max(1, ncs_object.max_operators()) else: n_ops = 1 # Get sequence if extract_unique is set sequence = None if params.extract_unique: if params.sequence_file: if n_ops > 1: # get unique part of sequence and multiply remove_duplicates = True else: remove_duplicates = False from iotbx.bioinformatics import get_sequences sequence = n_ops * (" ".join( get_sequences(file_name=params.sequence_file, remove_duplicates=remove_duplicates))) if sequence and not params.molecular_mass: # get molecular mass from sequence from iotbx.bioinformatics import text_from_chains_matching_chain_type if params.chain_type in [None, 'PROTEIN']: n_protein = len( text_from_chains_matching_chain_type(text=sequence, chain_type='PROTEIN')) else: n_protein = 0 if params.chain_type in [None, 'RNA']: n_rna = len( text_from_chains_matching_chain_type(text=sequence, chain_type='RNA')) else: n_rna = 0 if params.chain_type in [None, 'DNA']: n_dna = len( text_from_chains_matching_chain_type(text=sequence, chain_type='DNA')) else: n_dna = 0 params.molecular_mass = n_protein * 110 + (n_rna + n_dna) * 330 elif not params.molecular_mass: raise Sorry( "Need a sequence file or molecular mass for extract_unique") else: molecular_mass = None # if params.density_select: print_statistics.make_sub_header( "Extracting box around selected density and writing output files", out=log) else: print_statistics.make_sub_header( "Extracting box around selected atoms and writing output files", out=log) # if params.value_outside_atoms == 'mean': print >> log, "\nValue outside atoms mask will be set to mean inside mask" if params.get_half_height_width and params.density_select: print >> log, "\nHalf width at half height will be used to id boundaries" if params.soft_mask and sites_cart_all.size() > 0: print >> log, "\nSoft mask will be applied to model-based mask" if params.keep_map_size: print >> log, "\nEntire map will be kept (not cutting out region)" if params.restrict_map_size: print >> log, "\nOutput map will be within input map" if params.lower_bounds and params.upper_bounds: print >> log, "Bounds for cut out map are (%s,%s,%s) to (%s,%s,%s)" % ( tuple(list(params.lower_bounds) + list(params.upper_bounds))) box = mmtbx.utils.extract_box_around_model_and_map( xray_structure=xray_structure, map_data=map_data.as_double(), box_cushion=params.box_cushion, selection=selection, density_select=params.density_select, threshold=params.density_select_threshold, get_half_height_width=params.get_half_height_width, mask_atoms=params.mask_atoms, soft_mask=params.soft_mask, soft_mask_radius=params.soft_mask_radius, mask_atoms_atom_radius=params.mask_atoms_atom_radius, value_outside_atoms=params.value_outside_atoms, keep_map_size=params.keep_map_size, restrict_map_size=params.restrict_map_size, lower_bounds=params.lower_bounds, upper_bounds=params.upper_bounds, extract_unique=params.extract_unique, chain_type=params.chain_type, sequence=sequence, solvent_content=params.solvent_content, molecular_mass=params.molecular_mass, resolution=params.resolution, ncs_object=ncs_object, symmetry=params.symmetry, ) ph_box = pdb_hierarchy.select(selection) ph_box.adopt_xray_structure(box.xray_structure_box) box.hierarchy = ph_box if (inputs and inputs.crystal_symmetry and inputs.ccp4_map and inputs.crystal_symmetry.unit_cell().parameters() and inputs.ccp4_map.unit_cell_parameters) and ( inputs.crystal_symmetry.unit_cell().parameters() != inputs.ccp4_map.unit_cell_parameters): print >> log, "\nNOTE: Mismatch of unit cell parameters from CCP4 map:" print >>log,"Unit cell from CCP4 map 'unit cell parameters': "+\ "%.1f, %.1f, %.1f, %.1f, %.1f, %.1f)" %tuple( inputs.ccp4_map.unit_cell_parameters) print >>log,"Unit cell from CCP4 map 'map grid': "+\ "%.1f, %.1f, %.1f, %.1f, %.1f, %.1f)" %tuple( inputs.crystal_symmetry.unit_cell().parameters()) print >>log,"\nInterpreting this as the 'unit cell parameters' was "+\ "original map \ndimension and 'map grid' is the "+\ "portion actually in the map that was supplied here.\n" box.unit_cell_parameters_from_ccp4_map = inputs.ccp4_map.unit_cell_parameters box.unit_cell_parameters_deduced_from_map_grid=\ inputs.crystal_symmetry.unit_cell().parameters() else: box.unit_cell_parameters_from_ccp4_map = None box.unit_cell_parameters_deduced_from_map_grid = None # ncs_object is original # box.ncs_object is shifted by shift_cart print >> log, "Box cell dimensions: (%.2f, %.2f, %.2f) A" % ( box.box_crystal_symmetry.unit_cell().parameters()[:3]) if params.keep_origin: print >> log, "Box origin is at grid position of : (%d, %d, %d) " % ( tuple(box.origin_shift_grid_units(reverse=True))) print >> log, "Box origin is at coordinates: (%.2f, %.2f, %.2f) A" % ( tuple(-col(box.shift_cart))) if box.pdb_outside_box_msg: print >> log, box.pdb_outside_box_msg # NOTE: box object is always shifted to place origin at (0,0,0) # For output files ONLY: # keep_origin==False leave origin at (0,0,0) # keep_origin==True: we shift everything back to where it was, if (not params.keep_origin): if box.shift_cart: print >>log,\ "Final coordinate shift for output files: (%.2f,%.2f,%.2f) A" %( tuple(box.shift_cart)) else: print >>log,"\nOutput files are in same location as original: origin "+\ "is at (0,0,0)" else: # keep_origin print >> log, "\nOutput files are in same location as original, just cut out." print >> log, "Note that output maps are only valid in the cut out region.\n" if params.keep_origin: ph_box_original_location = ph_box.deep_copy() sites_cart = box.shift_sites_cart_back( box.xray_structure_box.sites_cart()) xrs_offset = ph_box_original_location.extract_xray_structure( crystal_symmetry=box.xray_structure_box.crystal_symmetry( )).replace_sites_cart(new_sites=sites_cart) ph_box_original_location.adopt_xray_structure(xrs_offset) box.hierarchy_original_location = ph_box_original_location else: box.hierarchy_original_location = None if write_output_files: # Write PDB file if ph_box.overall_counts().n_residues > 0: if (params.output_file_name_prefix is None): file_name = "%s_box.pdb" % output_prefix else: file_name = "%s.pdb" % params.output_file_name_prefix if params.keep_origin: # Keeping origin print >> log, "Writing boxed PDB with box unit cell and in "+\ "original\n position to: %s"%( file_name) ph_box_original_location.write_pdb_file( file_name=file_name, crystal_symmetry=box.xray_structure_box.crystal_symmetry()) else: # write box PDB in box cell print >> log, "Writing shifted boxed PDB to file: %s" % file_name ph_box.write_pdb_file( file_name=file_name, crystal_symmetry=box.xray_structure_box.crystal_symmetry()) # Write NCS file if NCS if ncs_object and ncs_object.max_operators() > 0: if (params.output_file_name_prefix is None): output_symmetry_file = "%s_box.ncs_spec" % output_prefix else: output_symmetry_file = "%s.ncs_spec" % params.output_file_name_prefix if params.keep_origin: if params.symmetry_file: print >> log, "\nDuplicating symmetry in %s and writing to %s" % ( params.symmetry_file, output_symmetry_file) else: print >> log, "\nWriting symmetry to %s" % ( output_symmetry_file) ncs_object.format_all_for_group_specification( file_name=output_symmetry_file) else: print >> log, "\nOffsetting symmetry in %s and writing to %s" % ( params.symmetry_file, output_symmetry_file) box.ncs_object.format_all_for_group_specification( file_name=output_symmetry_file) # Write ccp4 map. Shift back to original location if keep_origin=True if ("ccp4" in params.output_format): if (params.output_file_name_prefix is None): file_name = "%s_box.ccp4" % output_prefix else: file_name = "%s.ccp4" % params.output_file_name_prefix if params.keep_origin: print >> log, "Writing boxed map with box unit_cell and "+\ "original\n position to CCP4 formatted file: %s"%file_name else: print >> log, "Writing box map shifted to (0,0,0) to CCP4 "+\ "formatted file: %s"%file_name box.write_ccp4_map(file_name=file_name, shift_back=params.keep_origin) # Write xplor map. Shift back if keep_origin=True if ("xplor" in params.output_format): if (params.output_file_name_prefix is None): file_name = "%s_box.xplor" % output_prefix else: file_name = "%s.xplor" % params.output_file_name_prefix if params.keep_origin: print >> log, "Writing boxed map with box unit_cell and original "+\ "position\n to X-plor formatted file: %s"%file_name else: print >> log, "Writing box_map shifted to (0,0,0) to X-plor "+\ "formatted file: %s"%file_name box.write_xplor_map(file_name=file_name, shift_back=params.keep_origin) # Write mtz map coeffs. Shift back if keep_origin=True if ("mtz" in params.output_format): if (params.output_file_name_prefix is None): file_name = "%s_box.mtz" % output_prefix else: file_name = "%s.mtz" % params.output_file_name_prefix if params.keep_origin: print >> log, "Writing map coefficients with box_map unit_cell"+\ " but position matching\n "+\ " original position to MTZ file: %s"%file_name else: print >> log, "Writing box_map coefficients shifted to (0,0,0) "+\ "to MTZ file: %s"%file_name if (map_coeff is not None): d_min = map_coeff.d_min() elif params.resolution is not None: d_min = params.resolution else: d_min = maptbx.d_min_from_map( map_data=box.map_box, unit_cell=box.xray_structure_box.unit_cell()) box.map_coefficients(d_min=d_min, resolution_factor=params.resolution_factor, file_name=file_name, shift_back=params.keep_origin) print >> log return box
def __init__(self, fmodels, model, all_params, group_adp_selections=None, group_adp_selections_h=None, group_adp_params=group_adp_master_params.extract(), tls_selections=None, nm_selections=None, tls_params=tls_master_params.extract(), nm_params=nm_master_params.extract(), individual_adp_params=individual_adp_master_params.extract(), adp_restraints_params=adp_restraints_master_params.extract(), refine_adp_individual=None, refine_adp_group=None, refine_tls=None, refine_nm=None, tan_b_iso_max=None, restraints_manager=None, target_weights=None, macro_cycle=None, log=None, h_params=None, nproc=None): global time_adp_refinement_py scatterers = fmodels.fmodel_xray().xray_structure.scatterers() timer = user_plus_sys_time() if (log is None): log = sys.stdout tan_u_iso = False param = 0 if (tan_b_iso_max > 0.0): tan_u_iso = True param = int(tan_b_iso_max) if (macro_cycle == 1): offset = True else: offset = False if (refine_tls): print_statistics.make_sub_header(text="TLS refinement", out=log) tls_sel_st = flex.size_t() for ts in tls_selections: tls_sel_st.extend(ts) tls_sel_bool = flex.bool(scatterers.size(), flex.size_t(tls_sel_st)) ### totally ad hoc fix tmp_site_t = flex.size_t() for gs in group_adp_selections: for gs_ in gs: tmp_site_t.append(gs_) ### if (macro_cycle == 1 or tmp_site_t.size() != scatterers.size()): gbr_selections = [] for s in tls_selections: gbr_selections.append(s) else: gbr_selections = [] for gs in group_adp_selections: gbr_selection = flex.size_t() for gs_ in gs: if (tls_sel_bool[gs_]): gbr_selection.append(gs_) if (gbr_selection.size() > 0): gbr_selections.append(gbr_selection) gbr_selections_one_arr = flex.size_t() for gbs in gbr_selections: gbr_selections_one_arr.extend(gbs) scatterers = fmodels.fmodel_xray().xray_structure.scatterers() for gbr_selection in gbr_selections_one_arr: scatterers[gbr_selection].flags.set_use_u_iso(True) #group_b_manager = mmtbx.refinement.group.manager( # fmodel = fmodels.fmodel_xray(), # selections = gbr_selections, # convergence_test = group_adp_params.convergence_test, # max_number_of_iterations = 50, # number_of_macro_cycles = 1, # refine_adp = True, # log = log) scatterers = fmodels.fmodel_xray().xray_structure.scatterers() for tls_selection_ in tls_selections: for tls_selection__ in tls_selection_: scatterers[tls_selection__].flags.set_use_u_aniso(True) model.show_groups(tls=True, out=log) current_target_name = fmodels.fmodel_xray().target_name #fmodels.fmodel_xray().update(target_name = "ls_wunit_k1") tools.split_u(fmodels.fmodel_xray().xray_structure, tls_selections, offset) self.tls_refinement_manager = tools.tls_refinement( fmodel=fmodels.fmodel_xray(), model=model, selections=tls_selections, selections_1d=tls_sel_st, refine_T=tls_params.refine_T, refine_L=tls_params.refine_L, refine_S=tls_params.refine_S, number_of_macro_cycles=tls_params.number_of_macro_cycles, max_number_of_iterations=tls_params.max_number_of_iterations, start_tls_value=tls_params.start_tls_value, run_finite_differences_test=tls_params. run_finite_differences_test, eps=tls_params.eps, out=log, macro_cycle=macro_cycle, verbose=tls_params.verbose) fmodels.fmodel_xray().update(target_name=current_target_name) fmodels.update_xray_structure( xray_structure=self.tls_refinement_manager.fmodel. xray_structure, update_f_calc=True) model.xray_structure = fmodels.fmodel_xray().xray_structure if (refine_nm): print_statistics.make_sub_header(text="NM refinement", out=log) nm_sel_st = flex.size_t() for ns in nm_selections: nm_sel_st.extend(ns) nm_sel_bool = flex.bool(scatterers.size(), flex.size_t(nm_sel_st)) ### totally ad hoc fix tmp_site_t = flex.size_t() for gs in group_adp_selections: # print gs.size() for gs_ in gs: tmp_site_t.append(gs_) ### if (macro_cycle == 1 or tmp_site_t.size() != scatterers.size()): gbr_selections = [] # print "gbr selections are based on nm selections" for s in nm_selections: gbr_selections.append(s) else: gbr_selections = [] for gs in group_adp_selections: gbr_selection = flex.size_t() for gs_ in gs: if (nm_sel_bool[gs_]): gbr_selection.append(gs_) if (gbr_selection.size() > 0): gbr_selections.append(gbr_selection) #print "group length ", len(group_adp_selections) gbr_selections_one_arr = flex.size_t() for gbs in gbr_selections: gbr_selections_one_arr.extend(gbs) scatterers = fmodels.fmodel_xray().xray_structure.scatterers() for gbr_selection in gbr_selections_one_arr: scatterers[gbr_selection].flags.set_use_u_iso(True) if nm_params.group_b_refine: group_b_manager = mmtbx.refinement.group.manager( fmodel=fmodels.fmodel_xray(), selections=gbr_selections, convergence_test=group_adp_params.convergence_test, max_number_of_iterations=50, number_of_macro_cycles=1, refine_adp=True, log=log) scatterers = fmodels.fmodel_xray().xray_structure.scatterers() for nm_selection_ in nm_selections: for nm_selection__ in nm_selection_: scatterers[nm_selection__].flags.set_use_u_aniso(True) model.show_groups(nm=True, out=log) current_target_name = fmodels.fmodel_xray().target_name if (macro_cycle <= nm_params.stabilize_cycle): tools.split_u(fmodels.fmodel_xray().xray_structure, gbr_selections, offset) elif (macro_cycle <= nm_params.stabilize_cycle): u_eq = model.xray_structure_initial.extract_u_iso_or_u_equiv() nmtools.split_u(u_eq, fmodels.fmodel_xray().xray_structure, nm_selections, offset) else: u_eq = model.xray_structure.extract_u_iso_or_u_equiv() nmtools.split_u(u_eq, fmodels.fmodel_xray().xray_structure, nm_selections, offset) if not nm_params.update_target_function: fmodels.fmodel_xray().update(target_name="ls_wunit_k1") update_eigenvec = False if nm_params.update_evec and macro_cycle % nm_params.update_evec_per_cycle == 0: update_eigenvec = True self.nm_refinement_manager = nmtools.nm_refinement( fmodel=fmodels.fmodel_xray(), model=model, selections=nm_selections, selections_1d=nm_sel_st, n_modes=nm_params.n_modes, number_of_macro_cycles=nm_params.number_of_macro_cycles, max_number_of_iterations=nm_params.max_number_of_iterations, weight_nmre=nm_params.weight_nmre, evecin=nm_params.evecin, evalin=nm_params.evalin, fsub_evecin=nm_params.fsub_evecin, nm_params_filename=nm_params.nm_params_filename, zero_mode_flag=nm_params.zero_mode_flag, zero_mode_input_flag=nm_params.zero_mode_input_flag, update_evec=update_eigenvec, enmcalc_path=nm_params.enmcalc_path, start_xs_value=nm_params.start_xs_value, zero_mode_corr=nm_params.zero_mode_corr, fsub_ref=nm_params.fsub_ref, fsub_n_modes=nm_params.fsub_n_modes, run_finite_differences_test=nm_params. run_finite_differences_test, eps=nm_params.eps, out=log, macro_cycle=macro_cycle, verbose=nm_params.verbose) fmodels.fmodel_xray().update(target_name=current_target_name) fmodels.update_xray_structure( xray_structure=self.nm_refinement_manager.fmodel. xray_structure, update_f_calc=True) model.xray_structure = fmodels.fmodel_xray().xray_structure # from mmtbx.command_line import find_tls_groups # tls_params = find_tls_groups.master_phil.fetch().extract() # tls_params.nproc = 1 # tls_selections_str = find_tls_groups.find_tls( # params = tls_params, # pdb_inp = None, # pdb_hierarchy = model.pdb_hierarchy(), # xray_structure = model.xray_structure, # return_as_list = True, # out = log) # tls_selections = utils.get_atom_selections( # all_chain_proxies = model.all_chain_proxies, # selection_strings = tls_selections_str, # xray_structure = model.xray_structure) if (refine_adp_individual): refine_adp(model=model, fmodels=fmodels, target_weights=target_weights, individual_adp_params=individual_adp_params, adp_restraints_params=adp_restraints_params, h_params=h_params, log=log, all_params=all_params, nproc=nproc) if (refine_adp_group): print_statistics.make_sub_header( text="group isotropic ADP refinement", out=log) group_b_manager = mmtbx.refinement.group.manager( fmodel=fmodels.fmodel_xray(), selections=group_adp_selections, convergence_test=group_adp_params.convergence_test, max_number_of_iterations=group_adp_params. max_number_of_iterations, number_of_macro_cycles=group_adp_params.number_of_macro_cycles, run_finite_differences_test=group_adp_params. run_finite_differences_test, refine_adp=True, log=log) time_adp_refinement_py += timer.elapsed()
def run(args, crystal_symmetry=None, ncs_object=None, pdb_hierarchy=None, map_data=None, mask_data=None, half_map_data_list=None, half_map_labels_list=None, lower_bounds=None, upper_bounds=None, write_output_files=True, log=None): h = "phenix.map_box: extract box with model and map around selected atoms" if(log is None): log = sys.stdout print_statistics.make_header(h, out=log) default_message="""\ %s. Usage: phenix.map_box model.pdb map_coefficients.mtz selection="chain A and resseq 1:10" or phenix.map_box map.ccp4 density_select=True Parameters:"""%h if(len(args) == 0 and not pdb_hierarchy): print(default_message) master_phil.show(prefix=" ") return # Process inputs ignoring symmetry conflicts just to get the value of # ignore_symmetry_conflicts... inputs = mmtbx.utils.process_command_line_args(args = args, cmd_cs=crystal_symmetry, master_params = master_phil, suppress_symmetry_related_errors=True) params = inputs.params.extract() # Now process inputs for real and write a nice error message if necessary. try: inputs = mmtbx.utils.process_command_line_args(args = args, cmd_cs=crystal_symmetry, master_params = master_phil, suppress_symmetry_related_errors=params.ignore_symmetry_conflicts) except Exception as e: if str(e).find("symmetry mismatch ")>1: raise Sorry(str(e)+"\nTry 'ignore_symmetry_conflicts=True'") else: raise e params = inputs.params.extract() master_phil.format(python_object=params).show(out=log) # Overwrite params with parameters in call if available if lower_bounds: params.lower_bounds=lower_bounds if upper_bounds: params.upper_bounds=upper_bounds # PDB file if params.pdb_file and not inputs.pdb_file_names and not pdb_hierarchy: inputs.pdb_file_names=[params.pdb_file] if(len(inputs.pdb_file_names)!=1 and not params.density_select and not params.mask_select and not pdb_hierarchy and not params.keep_map_size and not params.upper_bounds and not params.extract_unique and not params.bounds_match_this_file): raise Sorry("PDB file is needed unless extract_unique, "+ "density_select, mask_select, keep_map_size \nor bounds are set .") if (len(inputs.pdb_file_names)!=1 and not pdb_hierarchy and \ (params.mask_atoms )): raise Sorry("PDB file is needed for mask_atoms") if params.soft_mask and (not params.resolution) and \ (len(inputs.pdb_file_names)!=1 and not pdb_hierarchy): raise Sorry("Need resolution for soft_mask without PDB file") if ((params.density_select or params.mask_select) and params.keep_map_size): raise Sorry("Cannot set both density_select/mask_select and keep_map_size") if ((params.density_select or params.mask_select) and params.upper_bounds): raise Sorry("Cannot set both density_select/mask_select and bounds") if (params.keep_map_size and params.upper_bounds): raise Sorry("Cannot set both keep_map_size and bounds") if (params.upper_bounds and not params.lower_bounds): raise Sorry("Please set lower_bounds if you set upper_bounds") if (params.extract_unique): if (not params.resolution): raise Sorry("Please set resolution for extract_unique") if (not params.symmetry) and (not params.symmetry_file) and \ (not ncs_object): raise Sorry( "Please supply a symmetry file or symmetry for extract_unique (you "+ "\ncan try symmetry=ALL if you do not know your symmetry or "+ "symmetry=C1 if \nthere is none)") from mmtbx.ncs.ncs import ncs ncs_object=ncs() ncs_object.set_unit_ncs() if params.keep_input_unit_cell_and_grid and ( (params.output_unit_cell_grid is not None ) or (params.output_unit_cell is not None ) ): raise Sorry("If you set keep_input_unit_cell_and_grid then you cannot "+\ "set \noutput_unit_cell_grid or output_unit_cell") if (write_output_files) and ("mtz" in params.output_format) and ( (params.keep_origin) and (not params.keep_map_size)): print("\nNOTE: Skipping write of mtz file as keep_origin=True and \n"+\ "keep_map_size is False\n") params.output_format=remove_element(params.output_format,element='mtz') if (write_output_files) and ("mtz" in params.output_format) and ( (params.extract_unique)): print("\nNOTE: Skipping write of mtz file as extract_unique=True\n") params.output_format=remove_element(params.output_format,element='mtz') if params.output_origin_match_this_file or params.bounds_match_this_file: if params.output_origin_match_this_file: fn=params.output_origin_match_this_file if params.bounds_match_this_file: raise Sorry("Cannot match origin and bounds at same time") else: fn=params.bounds_match_this_file if not params.ccp4_map_file: raise Sorry( "Need to specify your input file with ccp4_map_file=xxx if you use "+ "output_origin_match_this_file=xxxx or bounds_match_this_file=xxxx") af = any_file(fn) if (af.file_type == 'ccp4_map'): origin=af.file_content.data.origin() if params.output_origin_match_this_file: params.output_origin_grid_units=origin print("Origin of (%s,%s,%s) taken from %s" %( origin[0],origin[1],origin[2],fn)) else: all=af.file_content.data.all() params.lower_bounds=origin print("Lower bounds of (%s,%s,%s) taken from %s" %( params.lower_bounds[0],params.lower_bounds[1], params.lower_bounds[2],fn)) params.upper_bounds=list(col(origin)+col(all)-col((1,1,1))) print("upper bounds of (%s,%s,%s) taken from %s" %( params.upper_bounds[0],params.upper_bounds[1], params.upper_bounds[2],fn)) params.bounds_are_absolute=True else: raise Sorry("Unable to interpret %s as map file" %(fn)) if params.output_origin_grid_units is not None and params.keep_origin: params.keep_origin=False print("Setting keep_origin=False as output_origin_grid_units is set") print_statistics.make_sub_header("pdb model", out=log) if len(inputs.pdb_file_names)>0: pdb_inp = iotbx.pdb.input(file_name=inputs.pdb_file_names[0]) pdb_hierarchy = pdb_inp.construct_hierarchy() if pdb_hierarchy: pdb_atoms = pdb_hierarchy.atoms() pdb_atoms.reset_i_seq() else: pdb_hierarchy=None # Map or map coefficients map_coeff = None input_unit_cell_grid=None input_unit_cell=None input_map_labels=None if (not map_data): # read first mtz file if ( (len(inputs.reflection_file_names) > 0) or (params.map_coefficients_file is not None) ): # file in phil takes precedent if (params.map_coefficients_file is not None): if (len(inputs.reflection_file_names) == 0): inputs.reflection_file_names.append(params.map_coefficients_file) else: inputs.reflection_file_names[0] = params.map_coefficients_file map_coeff = reflection_file_utils.extract_miller_array_from_file( file_name = inputs.reflection_file_names[0], label = params.label, type = "complex", log = log) if not crystal_symmetry: crystal_symmetry=map_coeff.crystal_symmetry() fft_map = map_coeff.fft_map(resolution_factor=params.resolution_factor) fft_map.apply_sigma_scaling() map_data = fft_map.real_map_unpadded() map_or_map_coeffs_prefix=os.path.basename( inputs.reflection_file_names[0][:-4]) # or read CCP4 map elif ( (inputs.ccp4_map is not None) or (params.ccp4_map_file is not None) ): if (params.ccp4_map_file is not None): af = any_file(params.ccp4_map_file) if (af.file_type == 'ccp4_map'): inputs.ccp4_map = af.file_content inputs.ccp4_map_file_name = params.ccp4_map_file print_statistics.make_sub_header("CCP4 map", out=log) ccp4_map = inputs.ccp4_map ccp4_map.show_summary(prefix=" ",out=log) if not crystal_symmetry: crystal_symmetry=ccp4_map.crystal_symmetry() map_data = ccp4_map.data #map_data() input_unit_cell_grid=ccp4_map.unit_cell_grid input_unit_cell=ccp4_map.unit_cell_parameters input_map_labels=ccp4_map.get_labels() if inputs.ccp4_map_file_name.endswith(".ccp4"): map_or_map_coeffs_prefix=os.path.basename( inputs.ccp4_map_file_name[:-5]) else: map_or_map_coeffs_prefix=os.path.basename( inputs.ccp4_map_file_name[:-4]) else: # have map_data map_or_map_coeffs_prefix=None if params.half_map_list and (not half_map_data_list): if not params.extract_unique: raise Sorry("Can only use half_map_with extract_unique") print ("Reading half-maps",params.half_map_list) half_map_data_list=[] half_map_labels_list=[] for fn in params.half_map_list: print("Reading half map from %s" %(fn),file=log) af = any_file(fn) print_statistics.make_sub_header("CCP4 map", out=log) h_ccp4_map = af.file_content h_ccp4_map.show_summary(prefix=" ",out=log) h_map_data = h_ccp4_map.data half_map_data_list.append(h_map_data) half_map_labels_list.append(h_ccp4_map.get_labels()) if params.map_scale_factor: print("Applying scale factor of %s to map data on read-in" %( params.map_scale_factor)) map_data=map_data*params.map_scale_factor if params.output_origin_grid_units is not None: origin_to_match=tuple(params.output_origin_grid_units) else: origin_to_match=None if origin_to_match: sc=[] for x,o,a in zip(crystal_symmetry.unit_cell().parameters()[:3], origin_to_match, map_data.all()): sc.append(-x*o/a) shift_cart_for_origin_to_match=tuple(sc) else: origin_to_match=None shift_cart_for_origin_to_match=None if crystal_symmetry and not inputs.crystal_symmetry: inputs.crystal_symmetry=crystal_symmetry # final check that map_data exists if(map_data is None): raise Sorry("Map or map coefficients file is needed.") if len(inputs.pdb_file_names)>0: output_prefix=os.path.basename(inputs.pdb_file_names[0])[:-4] else: output_prefix=map_or_map_coeffs_prefix if not pdb_hierarchy: # get an empty hierarchy from cctbx.array_family import flex pdb_hierarchy=iotbx.pdb.input( source_info='',lines=flex.split_lines('')).construct_hierarchy() xray_structure = pdb_hierarchy.extract_xray_structure( crystal_symmetry=inputs.crystal_symmetry) xray_structure.show_summary(f=log) # if not params.selection: params.selection="all" selection = pdb_hierarchy.atom_selection_cache().selection( string = params.selection) if selection.size(): print_statistics.make_sub_header("atom selection", out=log) print("Selection string: selection='%s'"%params.selection, file=log) print(" selects %d atoms from total %d atoms."%(selection.count(True), selection.size()), file=log) sites_cart_all = xray_structure.sites_cart() sites_cart = sites_cart_all.select(selection) selection = xray_structure.selection_within( radius = params.selection_radius, selection = selection) if not ncs_object: from mmtbx.ncs.ncs import ncs ncs_object=ncs() if params.symmetry_file: ncs_object.read_ncs(params.symmetry_file,log=log) print("Total of %s operators read" %(ncs_object.max_operators()), file=log) if not ncs_object or ncs_object.max_operators()<1: print("No symmetry available", file=log) if ncs_object: n_ops=max(1,ncs_object.max_operators()) else: n_ops=1 # Get sequence if extract_unique is set sequence=None if params.extract_unique or params.mask_select: if params.sequence_file: if n_ops > 1: # get unique part of sequence remove_duplicates=True else: remove_duplicates=False from iotbx.bioinformatics import get_sequences sequence=(" ".join(get_sequences(file_name=params.sequence_file, remove_duplicates=remove_duplicates))) if params.chain_type in ['None',None]: params.chain_type=None if sequence and not params.molecular_mass: # get molecular mass from sequence from iotbx.bioinformatics import text_from_chains_matching_chain_type if params.chain_type in [None,'PROTEIN']: n_protein=len(text_from_chains_matching_chain_type( text=sequence,chain_type='PROTEIN')) else: n_protein=0 if params.chain_type in [None,'RNA']: n_rna=len(text_from_chains_matching_chain_type( text=sequence,chain_type='RNA')) else: n_rna=0 if params.chain_type in [None,'DNA']: n_dna=len(text_from_chains_matching_chain_type( text=sequence,chain_type='DNA')) else: n_dna=0 params.molecular_mass=n_ops*(n_protein*110+(n_rna+n_dna)*330) print("\nEstimate of molecular mass is %.0f " %(params.molecular_mass), file=log) if params.density_select or params.mask_select: print_statistics.make_sub_header( "Extracting box around selected density and writing output files", out=log) else: print_statistics.make_sub_header( "Extracting box around selected atoms and writing output files", out=log) # if params.value_outside_atoms=='mean': print("\nValue outside atoms mask will be set to mean inside mask", file=log) if params.get_half_height_width and params.density_select: print("\nHalf width at half height will be used to id boundaries", file=log) if params.soft_mask and sites_cart_all.size()>0: print("\nSoft mask will be applied to model-based mask", file=log) elif params.soft_mask: print ("\nSoft mask will be applied to outside of map box",file=log) if params.keep_map_size: print("\nEntire map will be kept (not cutting out region)", file=log) if params.restrict_map_size: print("\nOutput map will be within input map", file=log) if params.lower_bounds and params.upper_bounds: print("Bounds for cut out map are (%s,%s,%s) to (%s,%s,%s)" %( tuple(list(params.lower_bounds)+list(params.upper_bounds))), file=log) if mask_data: mask_data=mask_data.as_double() box = mmtbx.utils.extract_box_around_model_and_map( xray_structure = xray_structure, map_data = map_data.as_double(), mask_data = mask_data, box_cushion = params.box_cushion, selection = selection, mask_select = params.mask_select, density_select = params.density_select, threshold = params.density_select_threshold, get_half_height_width = params.get_half_height_width, mask_atoms = params.mask_atoms, soft_mask = params.soft_mask, soft_mask_radius = params.soft_mask_radius, mask_atoms_atom_radius = params.mask_atoms_atom_radius, value_outside_atoms = params.value_outside_atoms, keep_map_size = params.keep_map_size, restrict_map_size = params.restrict_map_size, lower_bounds = params.lower_bounds, upper_bounds = params.upper_bounds, bounds_are_absolute = params.bounds_are_absolute, zero_outside_original_map = params.zero_outside_original_map, extract_unique = params.extract_unique, target_ncs_au_file = params.target_ncs_au_file, regions_to_keep = params.regions_to_keep, box_buffer = params.box_buffer, soft_mask_extract_unique = params.soft_mask_extract_unique, mask_expand_ratio = params.mask_expand_ratio, keep_low_density = params.keep_low_density, chain_type = params.chain_type, sequence = sequence, solvent_content = params.solvent_content, molecular_mass = params.molecular_mass, resolution = params.resolution, ncs_object = ncs_object, symmetry = params.symmetry, half_map_data_list = half_map_data_list, ) ph_box = pdb_hierarchy.select(selection) ph_box.adopt_xray_structure(box.xray_structure_box) box.hierarchy=ph_box if params.mask_select: print("\nSolvent content used in mask_select: %.3f " %( box.get_solvent_content()),file=log) if (inputs and inputs.crystal_symmetry and inputs.ccp4_map and inputs.crystal_symmetry.unit_cell().parameters() and inputs.ccp4_map.unit_cell_parameters ) and ( inputs.crystal_symmetry.unit_cell().parameters() != inputs.ccp4_map.unit_cell_parameters): print("\nNOTE: Input CCP4 map is only part of unit cell:", file=log) print("Full unit cell ('unit cell parameters'): "+\ "(%.1f, %.1f, %.1f, %.1f, %.1f, %.1f) A" %tuple( inputs.ccp4_map.unit_cell_parameters), file=log) print("Size of CCP4 map 'map unit cell': "+\ "(%.1f, %.1f, %.1f, %.1f, %.1f, %.1f) A" %tuple( inputs.crystal_symmetry.unit_cell().parameters()), file=log) print("Full unit cell as grid units: (%s, %s, %s)" %( inputs.ccp4_map.unit_cell_grid), file=log) print("Map unit cell as grid units: (%s, %s, %s)" %( map_data.all()), file=log) box.unit_cell_parameters_from_ccp4_map=inputs.ccp4_map.unit_cell_parameters box.unit_cell_parameters_deduced_from_map_grid=\ inputs.crystal_symmetry.unit_cell().parameters() else: box.unit_cell_parameters_from_ccp4_map=None box.unit_cell_parameters_deduced_from_map_grid=None if box.pdb_outside_box_msg: print(box.pdb_outside_box_msg, file=log) # NOTE: box object is always shifted to place origin at (0,0,0) # NOTE ON ORIGIN SHIFTS: The shifts are applied locally here. The box # object is not affected and always has the origin at (0,0,0) # output_box is copy of box with shift_cart corresponding to the output # files. Normally this is the same as the original shift_cart. However # if user has specified a new output origin it will differ. # For output files ONLY: # keep_origin==False leave origin at (0,0,0) # keep_origin==True: we shift everything back to where it was, # output_origin_grid_units=10,10,10: output origin is at (10,10,10) # ncs_object is original # box.ncs_object is shifted by shift_cart # output_box.ncs_object is shifted back by -new shift_cart # Additional note on output unit_cell and grid_units. # The ccp4-style output map can specify the unit cell and grid units # corresponding to that cell. This can be separate from the origin and # number of grid points in the map as written. If specified, write these # out to the output ccp4 map and also use this unit cell for writing # any output PDB files from copy import deepcopy output_box=deepcopy(box) # won't use box below here except to return it print("\nBox cell dimensions: (%.2f, %.2f, %.2f) A" %( box.box_crystal_symmetry.unit_cell().parameters()[:3]), file=log) if box.shift_cart: print("Working origin moved from grid position of"+\ ": (%d, %d, %d) to (0,0,0) " %( tuple(box.origin_shift_grid_units(reverse=True))), file=log) print("Working origin moved from coordinates of:"+\ " (%.2f, %.2f, %.2f) A to (0,0,0)\n" %( tuple(-col(box.shift_cart))), file=log) if (params.keep_origin): print("\nRestoring original position for output files", file=log) print("Origin will be at grid position of"+\ ": (%d, %d, %d) " %( tuple(box.origin_shift_grid_units(reverse=True))), file=log) print("\nOutput files will be in same location as original", end=' ', file=log) if not params.keep_map_size: print("just cut out.", file=log) else: print("keeping entire map", file=log) print("Note that output maps are only valid in the cut out region.\n", file=log) else: if origin_to_match: output_box.shift_cart=shift_cart_for_origin_to_match if params.output_origin_grid_units: print("Output map origin to be shifted to match target", file=log) print("Placing origin at grid point (%s, %s, %s)" %( origin_to_match)+"\n"+ \ "Final coordinate shift for output files: (%.2f,%.2f,%.2f) A\n" %( tuple(col(output_box.shift_cart)-col(box.shift_cart))), file=log) elif box.shift_cart: output_box.shift_cart=(0,0,0) # not shifting back print("Final origin will be at (0,0,0)", file=log) print("Final coordinate shift for output files: (%.2f,%.2f,%.2f) A\n" %( tuple(col(output_box.shift_cart)-col(box.shift_cart))), file=log) else: print("\nOutput files are in same location as original and origin "+\ "is at (0,0,0)\n", file=log) print("\nBox grid: (%s, %s, %s) " %(output_box.map_box.all()),file=log) ph_output_box_output_location = ph_box.deep_copy() if output_box.shift_cart: # shift coordinates and NCS back by shift_cart # NOTE output_box.shift_cart could be different than box.shift_cart if # there is a target position for the origin and it is not the same as the # original origin. sites_cart = output_box.shift_sites_cart_back( output_box.xray_structure_box.sites_cart()) xrs_offset = ph_output_box_output_location.extract_xray_structure( crystal_symmetry=output_box.xray_structure_box.crystal_symmetry() ).replace_sites_cart(new_sites = sites_cart) ph_output_box_output_location.adopt_xray_structure(xrs_offset) if output_box.ncs_object: output_box.ncs_object=output_box.ncs_object.coordinate_offset( tuple(-col(output_box.shift_cart))) shift_back=True else: shift_back=False if params.keep_input_unit_cell_and_grid and \ (input_unit_cell_grid is not None) and \ (input_unit_cell is not None): params.output_unit_cell=input_unit_cell params.output_unit_cell_grid=input_unit_cell_grid print("Setting output unit cell parameters and unit cell grid to"+\ " match\ninput map file", file=log) if params.output_unit_cell: # Set output unit cell parameters from cctbx import crystal output_crystal_symmetry=crystal.symmetry( unit_cell=params.output_unit_cell, space_group="P1") output_unit_cell=output_crystal_symmetry.unit_cell() print("Output unit cell set to: %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)" %tuple( output_crystal_symmetry.unit_cell().parameters()), file=log) else: output_crystal_symmetry=None # ============= Check/set output unit cell grid and cell parameters ======= if params.output_unit_cell_grid or output_crystal_symmetry: if params.output_unit_cell_grid: output_unit_cell_grid=params.output_unit_cell_grid else: output_unit_cell_grid=output_box.map_box.all() print("Output unit cell grid set to: (%s, %s, %s)" %tuple( output_unit_cell_grid), file=log) expected_output_abc=[] box_spacing=[] output_spacing=[] box_abc=output_box.xray_structure_box.\ crystal_symmetry().unit_cell().parameters()[:3] if output_crystal_symmetry: output_abc=output_crystal_symmetry.unit_cell().parameters()[:3] else: output_abc=[None,None,None] for a_box,a_output,n_box,n_output in zip( box_abc, output_abc, output_box.map_box.all(), output_unit_cell_grid): expected_output_abc.append(a_box*n_output/n_box) box_spacing.append(a_box/n_box) if output_crystal_symmetry: output_spacing.append(a_output/n_output) else: output_spacing.append(a_box/n_box) if output_crystal_symmetry: # make sure it is compatible... r0=expected_output_abc[0]/output_abc[0] r1=expected_output_abc[1]/output_abc[1] r2=expected_output_abc[2]/output_abc[2] from libtbx.test_utils import approx_equal if not approx_equal(r0,r1,eps=0.001) or not approx_equal(r0,r2,eps=0.001): print("WARNING: output_unit_cell and cell_grid will "+\ "change ratio of grid spacing.\nOld spacings: "+\ "(%.2f, %.2f, %.2f) A " %(tuple(box_spacing))+\ "\nNew spacings: (%.2f, %.2f, %.2f) A \n" %(tuple(output_spacing)), file=log) else: output_abc=expected_output_abc from cctbx import crystal output_crystal_symmetry=crystal.symmetry( unit_cell=list(output_abc)+[90,90,90], space_group="P1") print("Output unit cell will be: (%.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n"%( tuple(output_crystal_symmetry.unit_cell().parameters())), file=log) else: output_unit_cell_grid = output_box.map_box.all() output_crystal_symmetry=output_box.xray_structure_box.crystal_symmetry() # ========== Done check/set output unit cell grid and cell parameters ===== if write_output_files: # Write PDB file if ph_box.overall_counts().n_residues>0: if(params.output_file_name_prefix is None): file_name = "%s_box.pdb"%output_prefix else: file_name = "%s.pdb"%params.output_file_name_prefix ph_output_box_output_location.write_pdb_file(file_name=file_name, crystal_symmetry = output_crystal_symmetry) print("Writing boxed PDB with box unit cell to %s" %( file_name), file=log) # Write NCS file if NCS if output_box.ncs_object and output_box.ncs_object.max_operators()>0: if(params.output_file_name_prefix is None): output_symmetry_file = "%s_box.ncs_spec"%output_prefix else: output_symmetry_file = "%s.ncs_spec"%params.output_file_name_prefix output_box.ncs_object.format_all_for_group_specification( file_name=output_symmetry_file) print("\nWriting symmetry to %s" %( output_symmetry_file), file=log) # Write ccp4 map. if("ccp4" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.ccp4"%output_prefix else: file_name = "%s.ccp4"%params.output_file_name_prefix from iotbx.mrcfile import create_output_labels if params.extract_unique: program_name='map_box using extract_unique' limitations=["extract_unique"] else: program_name='map_box' limitations=[] labels=create_output_labels(program_name=program_name, input_file_name=inputs.ccp4_map_file_name, input_labels=input_map_labels, limitations=limitations, output_labels=params.output_map_labels) output_box.write_ccp4_map(file_name=file_name, output_crystal_symmetry=output_crystal_symmetry, output_mean=params.output_ccp4_map_mean, output_sd=params.output_ccp4_map_sd, output_unit_cell_grid=output_unit_cell_grid, shift_back=shift_back, output_map_labels=labels, output_external_origin=params.output_external_origin) print("Writing boxed map "+\ "to CCP4 formatted file: %s"%file_name, file=log) if not params.half_map_list: params.half_map_list=[] if not output_box.map_box_half_map_list: output_box.map_box_half_map_list=[] if not half_map_labels_list: half_map_labels_list=len(output_box.map_box_half_map_list)*[None] for hm,labels,fn in zip( output_box.map_box_half_map_list, half_map_labels_list, params.half_map_list): # half maps matching labels=create_output_labels(program_name=program_name, input_file_name=fn, input_labels=labels, limitations=limitations, output_labels=params.output_map_labels) hm_fn="%s_box.ccp4" %( ".".join(os.path.basename(fn).split(".")[:-1])) output_box.write_ccp4_map(file_name=hm_fn, map_data=hm, output_crystal_symmetry=output_crystal_symmetry, output_mean=params.output_ccp4_map_mean, output_sd=params.output_ccp4_map_sd, output_unit_cell_grid=output_unit_cell_grid, shift_back=shift_back, output_map_labels=labels, output_external_origin=params.output_external_origin) print ("Writing boxed half map to: %s " %(hm_fn),file=log) # Write xplor map. Shift back if keep_origin=True if("xplor" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.xplor"%output_prefix else: file_name = "%s.xplor"%params.output_file_name_prefix output_box.write_xplor_map(file_name=file_name, output_crystal_symmetry=output_crystal_symmetry, output_unit_cell_grid=output_unit_cell_grid, shift_back=shift_back,) print("Writing boxed map "+\ "to X-plor formatted file: %s"%file_name, file=log) # Write mtz map coeffs. Shift back if keep_origin=True if("mtz" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.mtz"%output_prefix else: file_name = "%s.mtz"%params.output_file_name_prefix print("Writing map coefficients "+\ "to MTZ file: %s"%file_name, file=log) if(map_coeff is not None): d_min = map_coeff.d_min() elif params.resolution is not None: d_min = params.resolution else: d_min = maptbx.d_min_from_map(map_data=output_box.map_box, unit_cell=output_box.xray_structure_box.unit_cell()) output_box.map_coefficients(d_min=d_min, scale_max=params.scale_max, resolution_factor=params.resolution_factor, file_name=file_name, shift_back=shift_back) print(file=log) return box
def run(args, crystal_symmetry=None, log=None): h = "phenix.map_box: extract box with model and map around selected atoms" if(log is None): log = sys.stdout print_statistics.make_header(h, out=log) default_message="""\ %s. Usage: phenix.map_box model.pdb map_coefficients.mtz selection="chain A and resseq 1:10" or phenix.map_box map.ccp4 density_select=True Parameters:"""%h if(len(args) == 0): print default_message master_phil.show(prefix=" ") return inputs = mmtbx.utils.process_command_line_args(args = args, cmd_cs=crystal_symmetry, master_params = master_phil) params = inputs.params.extract() # PDB file if params.pdb_file and not inputs.pdb_file_names: inputs.pdb_file_names=[params.pdb_file] if(len(inputs.pdb_file_names)!=1 and not params.density_select): raise Sorry("PDB file is needed unless density_select is set.") print_statistics.make_sub_header("pdb model", out=log) if len(inputs.pdb_file_names)>0: pdb_inp = iotbx.pdb.input(file_name=inputs.pdb_file_names[0]) pdb_hierarchy = pdb_inp.construct_hierarchy() pdb_atoms = pdb_hierarchy.atoms() pdb_atoms.reset_i_seq() else: pdb_hierarchy=None # Map or map coefficients map_coeff = None if(inputs.ccp4_map is None): if(len(inputs.reflection_file_names)!=1): raise Sorry("Map or map coefficients file is needed.") map_coeff = reflection_file_utils.extract_miller_array_from_file( file_name = inputs.reflection_file_names[0], label = params.label, type = "complex", log = log) fft_map = map_coeff.fft_map(resolution_factor=params.resolution_factor) fft_map.apply_sigma_scaling() map_data = fft_map.real_map_unpadded() map_or_map_coeffs_prefix=os.path.basename( inputs.reflection_file_names[0][:-4]) else: print_statistics.make_sub_header("CCP4 map", out=log) ccp4_map = inputs.ccp4_map ccp4_map.show_summary(prefix=" ") map_data = ccp4_map.map_data() if inputs.ccp4_map_file_name.endswith(".ccp4"): map_or_map_coeffs_prefix=os.path.basename( inputs.ccp4_map_file_name[:-5]) else: map_or_map_coeffs_prefix=os.path.basename( inputs.ccp4_map_file_name[:-4]) # if len(inputs.pdb_file_names)>0: output_prefix=os.path.basename(inputs.pdb_file_names[0])[:-4] else: output_prefix=map_or_map_coeffs_prefix if not pdb_hierarchy: # get an empty hierarchy from cctbx.array_family import flex pdb_hierarchy=iotbx.pdb.input( source_info='',lines=flex.split_lines('')).construct_hierarchy() xray_structure = pdb_hierarchy.extract_xray_structure( crystal_symmetry=inputs.crystal_symmetry) xray_structure.show_summary(f=log) # selection = pdb_hierarchy.atom_selection_cache().selection( string = params.selection) if selection.size(): print_statistics.make_sub_header("atom selection", out=log) print >> log, "Selection string: selection='%s'"%params.selection print >> log, \ " selects %d atoms from total %d atoms."%(selection.count(True), selection.size()) sites_cart_all = xray_structure.sites_cart() sites_cart = sites_cart_all.select(selection) selection = xray_structure.selection_within( radius = params.selection_radius, selection = selection) # if params.density_select: print_statistics.make_sub_header( "Extracting box around selected density and writing output files", out=log) else: print_statistics.make_sub_header( "Extracting box around selected atoms and writing output files", out=log) # box = mmtbx.utils.extract_box_around_model_and_map( xray_structure = xray_structure, map_data = map_data.as_double(), box_cushion = params.box_cushion, selection = selection, density_select = params.density_select, threshold = params.density_select_threshold) if box.initial_shift_cart: print >>log,"\nInitial coordinate shift will be (%.1f,%.1f,%.1f)\n" %( box.initial_shift_cart) if box.total_shift_cart: print >>log,"Final coordinate shift: (%.1f,%.1f,%.1f)" %( box.total_shift_cart) print >>log,"Final cell dimensions: (%.1f,%.1f,%.1f)\n" %( box.box_crystal_symmetry.unit_cell().parameters()[:3]) if box.pdb_outside_box_msg: print >> log, box.pdb_outside_box_msg if(params.output_file_name_prefix is None): file_name = "%s_box.pdb"%output_prefix else: file_name = "%s.pdb"%params.output_file_name_prefix ph_box = pdb_hierarchy.select(selection) ph_box.adopt_xray_structure(box.xray_structure_box) ph_box.write_pdb_file(file_name=file_name, crystal_symmetry = box.xray_structure_box.crystal_symmetry()) if("ccp4" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.ccp4"%output_prefix else: file_name = "%s.ccp4"%params.output_file_name_prefix print >> log, "writing map to CCP4 formatted file: %s"%file_name box.write_ccp4_map(file_name=file_name) if("xplor" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.xplor"%output_prefix else: file_name = "%s.xplor"%params.output_file_name_prefix print >> log, "writing map to X-plor formatted file: %s"%file_name box.write_xplor_map(file_name=file_name) if("mtz" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.mtz"%output_prefix else: file_name = "%s.mtz"%params.output_file_name_prefix print >> log, "writing map coefficients to MTZ file: %s"%file_name if(map_coeff is not None): d_min = map_coeff.d_min() else: d_min = maptbx.d_min_from_map(map_data=box.map_box, unit_cell=box.xray_structure_box.unit_cell()) box.map_coefficients(d_min=d_min, resolution_factor=params.resolution_factor, file_name=file_name) if params.ncs_file: if(params.output_file_name_prefix is None): output_ncs_file = "%s_box.ncs_spec"%output_prefix else: output_ncs_file = "%s.ncs_spec"%params.output_file_name_prefix print >>log,"\nOffsetting NCS in %s and writing to %s" %( params.ncs_file,output_ncs_file) from mmtbx.ncs.ncs import ncs ncs_object=ncs() ncs_object.read_ncs(params.ncs_file,log=log) ncs_object.display_all(log=log) if not ncs_object or ncs_object.max_operators()<1: print >>log,"Skipping...no NCS available" elif box.total_shift_cart: from scitbx.math import matrix print >>log,"Shifting NCS operators "+\ "based on coordinate shift of (%7.1f,%7.1f,%7.1f)" %( tuple(box.total_shift_cart)) ncs_object=ncs_object.coordinate_offset( coordinate_offset=matrix.col(box.total_shift_cart)) ncs_object.display_all(log=log) ncs_object.format_all_for_group_specification( file_name=output_ncs_file) box.ncs_object=ncs_object else: box.ncs_object=None print >> log return box
"set \noutput_unit_cell_grid or output_unit_cell") if (write_output_files) and ("mtz" in params.output_format) and ( (params.keep_origin) and (not params.keep_map_size)): print "\nNOTE: Skipping write of mtz file as keep_origin=True and \n"+\ "keep_map_size is False\n" new_output_format = [] for x in params.output_format: if x != 'mtz': new_output_format.append(x) params.output_format = new_output_format if params.output_origin_grid_units is not None and params.keep_origin: params.keep_origin = False print "Setting keep_origin=False as output_origin_grid_units is set" print_statistics.make_sub_header("pdb model", out=log) if len(inputs.pdb_file_names) > 0: pdb_inp = iotbx.pdb.input(file_name=inputs.pdb_file_names[0]) pdb_hierarchy = pdb_inp.construct_hierarchy() if pdb_hierarchy: pdb_atoms = pdb_hierarchy.atoms() pdb_atoms.reset_i_seq() else: pdb_hierarchy = None # Map or map coefficients map_coeff = None input_unit_cell_grid = None input_unit_cell = None if (not map_data): # read first mtz file if ((len(inputs.reflection_file_names) > 0)
def __init__(self, fmodel, selections = None, params = None, r_initial = None, t_initial = None, bss = None, log = None, monitors = None): global time_rigid_body_total self.params = params save_original_target_name = fmodel.target_name save_bss_anisotropic_scaling = None if(bss is not None): save_bss_anisotropic_scaling = bss.anisotropic_scaling timer_rigid_body_total = user_plus_sys_time() save_r_work = fmodel.r_work() save_r_free = fmodel.r_free() save_xray_structure = fmodel.xray_structure.deep_copy_scatterers() if(log is None): log = sys.stdout if(selections is None): selections = [] selections.append(flex.bool( fmodel.xray_structure.scatterers().size(), True).iselection()) else: assert len(selections) > 0 fmodel.xray_structure.scatterers().flags_set_grads(state=False) fmodel.xray_structure.scatterers().flags_set_grad_site( iselection = flex.bool(fmodel.xray_structure.scatterers().size(), True ).iselection()) self.total_rotation = [] self.total_translation = [] for item in selections: self.total_rotation.append(flex.double(3,0)) self.total_translation.append(flex.double(3,0)) if(r_initial is None): r_initial = [] for item in selections: r_initial.append(flex.double(3,0)) if(t_initial is None): t_initial = [] for item in selections: t_initial.append(flex.double(3,0)) fmodel_copy = fmodel.deep_copy() if(fmodel_copy.mask_params is not None): fmodel_copy.mask_params.verbose = -1 d_mins, target_names = split_resolution_range( d_spacings = fmodel_copy.f_obs_work().d_spacings().data(), n_bodies = len(selections), target = params.target, target_auto_switch_resolution = params.target_auto_switch_resolution, n_ref_first = params.min_number_of_reflections, multi_body_factor_n_ref_first = params.multi_body_factor, d_low = params.max_low_high_res_limit, d_high = params.high_resolution, number_of_zones = params.number_of_zones, zone_exponent = params.zone_exponent, log = log) print >> log if (fmodel.target_name != target_names[0]): fmodel.update(target_name=target_names[0]) self.show(fmodel = fmodel, r_mat = self.total_rotation, t_vec = self.total_translation, header = "Start", out = log) if (params.number_of_zones == 1 or monitors is None): monitors_call_back_handler = None else: monitors_call_back_handler = monitors.call_back_handler if (monitors_call_back_handler is not None): monitors_call_back_handler( monitor=None, model=None, fmodel=fmodel, method="rigid_body") for res,target_name in zip(d_mins, target_names): xrs = fmodel_copy.xray_structure.deep_copy_scatterers() fmodel_copy = fmodel.resolution_filter(d_min = res) if (fmodel_copy.target_name != target_name): fmodel_copy.update(target_name=target_name) d_max_min = fmodel_copy.f_obs_work().d_max_min() line = "Refinement at resolution: "+\ str("%7.2f"%d_max_min[0]).strip() + " - " \ + str("%6.2f"%d_max_min[1]).strip() \ + " target=" + fmodel_copy.target_name print_statistics.make_sub_header(line, out = log) fmodel_copy.update_xray_structure(xray_structure = xrs, update_f_calc = True) rworks = flex.double() if(len(d_mins) == 1): n_rigid_body_minimizer_cycles = 1 else: n_rigid_body_minimizer_cycles = min(int(res),4) for i_macro_cycle in xrange(n_rigid_body_minimizer_cycles): if(bss is not None and params.bulk_solvent_and_scale): if(fmodel_copy.f_obs().d_min() > 3.0): bss.anisotropic_scaling=False fast=True if(bss.mode=="slow"): fast=False fmodel_copy.update_all_scales( update_f_part1 = False, params = bss, fast = fast, log = log, remove_outliers = False, optimize_mask = False, refine_hd_scattering = False) if(fmodel_copy.f_obs().d_min() > 3.0): assert save_bss_anisotropic_scaling is not None bss.anisotropic_scaling = save_bss_anisotropic_scaling bss.minimization_b_cart = save_bss_anisotropic_scaling minimized = rigid_body_minimizer( fmodel = fmodel_copy, selections = selections, r_initial = r_initial, t_initial = t_initial, refine_r = params.refine_rotation, refine_t = params.refine_translation, max_iterations = params.max_iterations, euler_angle_convention = params.euler_angle_convention, lbfgs_maxfev = params.lbfgs_line_search_max_function_evaluations) rotation_matrices = [] translation_vectors = [] for i in xrange(len(selections)): self.total_rotation[i] += flex.double(minimized.r_min[i]) self.total_translation[i] += flex.double(minimized.t_min[i]) rot_obj = scitbx.rigid_body.euler( phi = minimized.r_min[i][0], psi = minimized.r_min[i][1], the = minimized.r_min[i][2], convention = params.euler_angle_convention) rotation_matrices.append(rot_obj.rot_mat()) translation_vectors.append(minimized.t_min[i]) new_xrs = apply_transformation( xray_structure = minimized.fmodel.xray_structure, rotation_matrices = rotation_matrices, translation_vectors = translation_vectors, selections = selections) fmodel_copy.update_xray_structure(xray_structure = new_xrs, update_f_calc = True, update_f_mask = True) rwork = minimized.fmodel.r_work() rfree = minimized.fmodel.r_free() assert approx_equal(rwork, fmodel_copy.r_work()) fmodel.update_xray_structure( xray_structure = fmodel_copy.xray_structure, update_f_calc = True, update_f_mask = True) if(bss is not None and params.bulk_solvent_and_scale): fast=True if(bss.mode=="slow"): fast=False fmodel_copy.update_all_scales( update_f_part1 = False, params = bss, fast = fast, log = log, remove_outliers = False, optimize_mask = False, refine_hd_scattering = False) self.show(fmodel = fmodel, r_mat = self.total_rotation, t_vec = self.total_translation, header = "Rigid body refinement", out = log) if (monitors_call_back_handler is not None): monitors_call_back_handler( monitor=None, model=None, fmodel=fmodel, method="rigid_body") if(bss is not None and params.bulk_solvent_and_scale): fast=True if(bss.mode=="slow"): fast=False fmodel_copy.update_all_scales( update_f_part1 = False, params = bss, fast = fast, log = log, remove_outliers = False, optimize_mask = False, refine_hd_scattering = False) print >> log self.show(fmodel = fmodel, r_mat = self.total_rotation, t_vec = self.total_translation, header = "Rigid body end", out = log) print >> log self.evaluate_after_end(fmodel, save_r_work, save_r_free, save_xray_structure, log) self.fmodel = fmodel self.fmodel.update(target_name = save_original_target_name) time_rigid_body_total += timer_rigid_body_total.elapsed()
def run(fmodel, geometry_restraints_manager, pdb_hierarchy, solvent_selection, optimize_hd=False, log=None, params=None): if (log is None): log = sys.stdout if (params is None): params = master_params().extract() print_statistics.make_sub_header(text="Fitting sidechains", out=log) mon_lib_srv = mmtbx.monomer_library.server.server() if (params.use_dihedral_restraints): sel = flex.bool(fmodel.xray_structure.scatterers().size(), True) geometry_restraints_manager = geometry_restraints_manager.select(sel) geometry_restraints_manager.remove_dihedrals_in_place(sel) restraints_manager = mmtbx.restraints.manager( geometry=geometry_restraints_manager, normalization=True) model = mmtbx.model.manager(restraints_manager=restraints_manager, xray_structure=fmodel.xray_structure, pdb_hierarchy=pdb_hierarchy) backbone_selections = model.backbone_selections() if (params.ignore_water_when_move_sidechains): selection = ~model.solvent_selection() else: selection = flex.bool(model.xray_structure.scatterers().size(), True) selection &= backbone_selections fmt = "Macro-cycle %2d: r_work=%6.4f r_free=%6.4f" print >> log, fmt % (0, fmodel.r_work(), fmodel.r_free()) for macro_cycle in range(1, params.number_of_macro_cycles + 1): target_map_data, fft_map_1 = get_map_data( fmodel=fmodel, map_type=params.target_map, exclude_free_r_reflections=params.exclude_free_r_reflections) model_map_data, fft_map_2 = get_map_data(fmodel=fmodel, map_type=params.model_map) residual_map_data, fft_map_3 = get_map_data( fmodel=fmodel, map_type=params.residual_map, exclude_free_r_reflections=params.exclude_free_r_reflections) if (params.filter_residual_map_value is not None): #XXX use filtering.... map_sel = flex.abs( residual_map_data) < params.filter_residual_map_value residual_map_data = residual_map_data.set_selected(map_sel, 0) if (params.filter_2fofc_map is not None): map_sel = flex.abs(target_map_data) < params.filter_2fofc_map target_map_data = target_map_data.set_selected(map_sel, 0) rsr_manager = refiner( pdb_hierarchy=pdb_hierarchy, target_map=target_map_data, geometry_restraints_manager=geometry_restraints_manager, real_space_target_weight=params.residue_iteration. real_space_refine_target_weight, real_space_gradients_delta=fmodel.f_obs().d_min() / 4, max_iterations=params.residue_iteration. real_space_refine_max_iterations) residue_rsr_monitor = residue_iteration( pdb_hierarchy=pdb_hierarchy, xray_structure=fmodel.xray_structure, selection=selection, target_map_data=target_map_data, model_map_data=model_map_data, residual_map_data=residual_map_data, mon_lib_srv=mon_lib_srv, rsr_manager=rsr_manager, optimize_hd=optimize_hd, params=params.residue_iteration, log=log) fmodel.update_xray_structure(update_f_calc=True, update_f_mask=True) print >> log, "1:", fmt % (macro_cycle, fmodel.r_work(), fmodel.r_free()) del target_map_data, model_map_data, residual_map_data, fft_map_1, fft_map_2, fft_map_3 if (params.validate_change): validate_changes(fmodel=fmodel, residue_rsr_monitor=residue_rsr_monitor, validate_method=None, log=log)
def __init__( self, model, fmodels, target_weights, individual_adp_params, adp_restraints_params, h_params, log, all_params, nproc=None): adopt_init_args(self, locals()) d_min = fmodels.fmodel_xray().f_obs().d_min() # initialize with defaults... if(target_weights is not None): import mmtbx.refinement.weights_params wcp = mmtbx.refinement.weights_params.tw_customizations_params.extract() for w_s_c in wcp.weight_selection_criteria: if(d_min >= w_s_c.d_min and d_min < w_s_c.d_max): r_free_range_width = w_s_c.r_free_range_width r_free_r_work_gap = w_s_c.r_free_minus_r_work mean_diff_b_iso_bonded_fraction = w_s_c.mean_diff_b_iso_bonded_fraction min_diff_b_iso_bonded = w_s_c.min_diff_b_iso_bonded break # ...then customize wsc = all_params.target_weights.weight_selection_criteria if(wsc.r_free_minus_r_work is not None): r_free_r_work_gap = wsc.r_free_minus_r_work if(wsc.r_free_range_width is not None): r_free_range_width = wsc.r_free_range_width if(wsc.mean_diff_b_iso_bonded_fraction is not None): mean_diff_b_iso_bonded_fraction = wsc.mean_diff_b_iso_bonded_fraction if(wsc.min_diff_b_iso_bonded is not None): min_diff_b_iso_bonded = wsc.min_diff_b_iso_bonded # print_statistics.make_sub_header(text="Individual ADP refinement", out = log) assert fmodels.fmodel_xray().xray_structure is model.xray_structure # fmodels.create_target_functors() assert approx_equal(self.fmodels.fmodel_xray().target_w(), self.fmodels.target_functor_result_xray( compute_gradients=False).target_work()) rw = flex.double() rf = flex.double() rfrw = flex.double() deltab = flex.double() w = flex.double() if(self.target_weights is not None): fmth =" R-FACTORS <Bi-Bj> <B> WEIGHT TARGETS" print >> self.log, fmth print >> self.log, " work free delta data restr" else: print >> self.log, "Unresrained refinement..." self.save_scatterers = self.fmodels.fmodel_xray().xray_structure.\ deep_copy_scatterers().scatterers() if(self.target_weights is not None): default_weight = self.target_weights.adp_weights_result.wx*\ self.target_weights.adp_weights_result.wx_scale if(self.target_weights.twp.optimize_adp_weight): wx_scale = [0.03,0.125,0.5,1.,1.5,2.,2.5,3.,3.5,4.,4.5,5.] trial_weights = list( flex.double(wx_scale)*self.target_weights.adp_weights_result.wx ) self.wx_scale = 1 else: trial_weights = [self.target_weights.adp_weights_result.wx] self.wx_scale = self.target_weights.adp_weights_result.wx_scale else: default_weight = 1 trial_weights = [1] self.wx_scale = 1 self.show(weight=default_weight) trial_results = [] if nproc is None: nproc = all_params.main.nproc parallel = False if (len(trial_weights) > 1) and ((nproc is Auto) or (nproc > 1)) : parallel = True from libtbx import easy_mp stdout_and_results = easy_mp.pool_map( processes=nproc, fixed_func=self.try_weight, args=trial_weights, func_wrapper="buffer_stdout_stderr") # XXX safer for phenix GUI trial_results = [ r for so, r in stdout_and_results ] else : for weight in trial_weights: result = self.try_weight(weight, print_stats=True) trial_results.append(result) for result in trial_results : if(result is not None) and (result.r_work is not None) : if (parallel) : result.show(out=self.log) rw .append(result.r_work) rf .append(result.r_free) rfrw .append(result.r_gap) deltab .append(result.delta_b) w .append(result.weight) # if(len(trial_weights)>1): # filter by rfree-rwork rw,rf,rfrw,deltab,w = self.score(rw=rw,rf=rf,rfrw=rfrw,deltab=deltab,w=w, score_target=rfrw,score_target_value=r_free_r_work_gap, secondary_target=deltab) # filter by rfree rw,rf,rfrw,deltab,w = self.score(rw=rw,rf=rf,rfrw=rfrw,deltab=deltab,w=w, score_target=rf,score_target_value=flex.min(rf)+r_free_range_width) # filter by <Bi-Bj> delta_b_target = max(min_diff_b_iso_bonded, flex.mean(self.fmodels. fmodel_xray().xray_structure.extract_u_iso_or_u_equiv()* adptbx.u_as_b(1))*mean_diff_b_iso_bonded_fraction) print >> log, " max suggested <Bi-Bj> for this run: %7.2f"%delta_b_target print >> log, " max allowed Rfree-Rwork gap: %5.1f"%r_free_r_work_gap print >> log, " range of equivalent Rfree: %5.1f"%r_free_range_width rw,rf,rfrw,deltab,w = self.score(rw=rw,rf=rf,rfrw=rfrw,deltab=deltab,w=w, score_target=deltab,score_target_value=delta_b_target) # select the result with lowest rfree sel = flex.sort_permutation(rf) rw,rf,rfrw,deltab,w= self.select( rw=rw,rf=rf,rfrw=rfrw,deltab=deltab,w=w,sel=sel) # w_best = w[0] rw_best = rw[0] print >> self.log, "Best ADP weight: %8.3f"%w_best # self.target_weights.adp_weights_result.wx = w_best self.target_weights.adp_weights_result.wx_scale = 1 best_u_star = None best_u_iso = None for result in trial_results : if(abs(result.weight-w_best)<=1.e-8) : best_u_star = result.u_star best_u_iso = result.u_iso break if(best_u_iso is None) : # XXX this probably shouldn't happen... self.fmodels.fmodel_xray().xray_structure.replace_scatterers( self.save_scatterers.deep_copy()) else : assert (best_u_star is not None) xrs = self.fmodels.fmodel_xray().xray_structure xrs.set_u_iso(values=best_u_iso) xrs.scatterers().set_u_star(best_u_star) new_u_iso = xrs.scatterers().extract_u_iso() assert (new_u_iso.all_eq(best_u_iso)) self.fmodels.update_xray_structure( xray_structure = self.fmodels.fmodel_xray().xray_structure, update_f_calc = True) print >> self.log, "Accepted refinement result:" # reset alpha/beta parameters - if this is not done, the assertion # below will fail fmodels.create_target_functors() if(self.fmodels.fmodel_neutron() is None): assert approx_equal(self.fmodels.fmodel_xray().r_work()*100, rw_best, eps=0.001) # this needs to be done again again, just in case fmodels.create_target_functors() self.show(weight=w_best) self.fmodels.fmodel_xray().xray_structure.tidy_us() assert approx_equal(self.fmodels.fmodel_xray().target_w(), self.fmodels.target_functor_result_xray( compute_gradients=False).target_work()) self.model.xray_structure = self.fmodels.fmodel_xray().xray_structure
def __init__( self, fmodels, model, params, target_weights, macro_cycle, ncs_manager=None, log=None): if log is None: log = sys.stdout # self.ncs_manager = ncs_manager self.nproc = params.main.nproc if self.nproc is Auto: self.nproc = 1 self.verbose = params.den.verbose self.log = log self.fmodels = fmodels self.model = model self.params = params self.target_weights = target_weights self.adp_refinement_manager = None self.macro_cycle = macro_cycle self.tan_b_iso_max = 0 self.random_seed = params.main.random_seed den_manager = model.restraints_manager. \ geometry.den_manager print_statistics.make_header("DEN refinement", out=self.log) pdb_hierarchy = self.model.get_hierarchy(sync_with_xray_structure=True) if den_manager.get_n_proxies() == 0: print_statistics.make_sub_header( "DEN restraint nework", out = self.log) den_manager.build_den_proxies(pdb_hierarchy=pdb_hierarchy) den_manager.build_den_restraints() den_manager.show_den_summary( sites_cart=self.model.get_sites_cart()) if den_manager.params.output_kinemage: den_manager.output_kinemage( self.model.get_sites_cart()) print_statistics.make_sub_header( "coordinate minimization before annealing", out=self.log) self.minimize(ca_only=self.params.den.minimize_c_alpha_only) self.save_scatterers_local = fmodels.fmodel_xray().\ xray_structure.deep_copy_scatterers().scatterers() #DEN refinement start, turn on if params.den.optimize: grid = den_manager.get_optimization_grid() print >> log, \ "Running DEN torsion optimization on %d processors..." % \ params.main.nproc else: grid = [(params.den.gamma, params.den.weight)] grid_results = [] grid_so = [] if "torsion" in params.den.annealing_type: print >> self.log, "Running torsion simulated annealing" if ( (params.den.optimize) and ( (self.nproc is Auto) or (self.nproc > 1) )): stdout_and_results = easy_mp.pool_map( processes=params.main.nproc, fixed_func=self.try_den_weight_torsion, args=grid, func_wrapper="buffer_stdout_stderr") for so, r in stdout_and_results: if (r is None): raise RuntimeError(("DEN weight optimization failed:"+ "\n%s\nThis is a "+ "serious error; please contact [email protected].") % so) grid_so.append(so) grid_results.append(r) else: for grid_pair in grid: result = self.try_den_weight_torsion( grid_pair=grid_pair) grid_results.append(result) self.show_den_opt_summary_torsion(grid_results) elif "cartesian" in params.den.annealing_type: print >> self.log, "Running Cartesian simulated annealing" if ( (params.den.optimize) and ( (self.nproc is Auto) or (self.nproc > 1) )): stdout_and_results = easy_mp.pool_map( processes=params.main.nproc, fixed_func=self.try_den_weight_cartesian, args=grid, func_wrapper="buffer_stdout_stderr") for so, r in stdout_and_results: if (r is None): raise RuntimeError(("DEN weight optimization failed:"+ "\n%s\nThis is a "+ "serious error; please contact [email protected].") % so) grid_so.append(so) grid_results.append(r) else: for grid_pair in grid: result = self.try_den_weight_cartesian( grid_pair=grid_pair) grid_results.append(result) self.show_den_opt_summary_cartesian(grid_results) else: raise "error in DEN annealing type" low_r_free = 1.0 best_xray_structure = None best_eq_distances = None best_gamma = None best_weight = None best_so_i = None for i, result in enumerate(grid_results): cur_r_free = result[2] if cur_r_free < low_r_free: low_r_free = cur_r_free best_gamma = result[0] best_weight = result[1] best_xray_structure = result[3] best_eq_distances = result[4] best_so_i = i assert best_xray_structure is not None if params.den.optimize: print >> self.log, "\nbest gamma: %.1f" % best_gamma print >> self.log, "best weight: %.1f\n" % best_weight if params.den.verbose: if len(grid_so) >= (best_so_i+1): print >> self.log, "\nBest annealing results:\n" print >> self.log, grid_so[best_so_i] fmodels.fmodel_xray().xray_structure.replace_scatterers( best_xray_structure.deep_copy()) fmodels.update_xray_structure( xray_structure = fmodels.fmodel_xray().xray_structure, update_f_calc = True) utils.assert_xray_structures_equal( x1 = fmodels.fmodel_xray().xray_structure, x2 = model.get_xray_structure()) model.restraints_manager.geometry.\ den_manager.import_eq_distances(eq_distances=best_eq_distances) self.model.torsion_ncs_restraints_update(log=self.log)
def find_tls (params, pdb_inp, pdb_hierarchy, xray_structure, return_as_list=False, ignore_pdb_header_groups=False, out=None) : if (out is None) : out = sys.stdout print_statistics.make_header("Analyzing inputs", out=out) if (params.random_seed is None) : params.random_seed = flex.get_random_seed() random.seed(params.random_seed) flex.set_random_seed(params.random_seed) xray_structure.convert_to_isotropic() sites_cart = xray_structure.sites_cart() u_cart = None u_iso = xray_structure.extract_u_iso_or_u_equiv()#*adptbx.u_as_b(1.) # ? bad_i_seqs = check_adp(u_iso=u_iso, out=out) if (bad_i_seqs is not None) : atoms = pdb_hierarchy.atoms() bad_atom_strings = [] for i_seq in bad_i_seqs[:10] : atom_str = atoms[i_seq].format_atom_record() bad_atom_strings.append(atom_str) if (len(bad_i_seqs) > 10) : bad_atom_strings.append("... (remaining %d not shown)" % (len(bad_i_seqs)-10)) raise Sorry(("%d atoms in the model contain isotropic B-factors <= 0:\n"+ "\n".join(bad_atom_strings)) % (len(bad_i_seqs))) # ssm = mmtbx.secondary_structure.manager( pdb_hierarchy = pdb_hierarchy, sec_str_from_pdb_file = None, params = None) alpha_h_selection = ssm.alpha_selection() secondary_structure_selection = ssm.alpha_selection() | \ ssm.beta_selection() | ssm.base_pair_selection() if(u_cart is not None): assert secondary_structure_selection.size() == u_cart.size() else: assert secondary_structure_selection.size() == u_iso.size() ssm.show_summary(log=out) chains_and_residue_selections, secondary_structure_selection = chains_and_atoms( pdb_hierarchy = pdb_hierarchy, secondary_structure_selection = secondary_structure_selection, out = out) chains_and_permutations = [] chains_and_atom_selection_strings = [] print_statistics.make_header("Processing chains", out=out) if (params.nproc is None) : params.nproc = 1 for crs in chains_and_residue_selections: print_statistics.make_sub_header("Processing chain '%s'"%crs[0], out=out) chain_selection = chain_selection_from_residues(crs[1]) groups, perms = get_model_partitioning(residues = crs[1], secondary_structure_selection = secondary_structure_selection, out = out) # #print #selection_arrays = sels_as_selection_arrays(sels = groups) #merge_groups_by_connectivity( # pdb_hierarchy = pdb_hierarchy, # xray_structure = xray_structure, # selection_arrays = selection_arrays) #assert 0 # if(len(perms)==1): print >> out, " Whole chain is considered as one TLS group." chains_and_atom_selection_strings.append([crs[0], permutations_as_atom_selection_string(groups, perms[0])]) else: print >> out, " Fitting TLS matrices..." dic = {} target_best = 1.e+9 if (params.nproc is Auto) or (params.nproc > 1) : process_perms = analyze_permutations( groups=groups, sites_cart=sites_cart, u_cart=u_cart, u_iso=u_iso) from libtbx import easy_mp stdout_and_targets = easy_mp.pool_map( processes=params.nproc, fixed_func=process_perms, args=perms, chunksize=100, func_wrapper="buffer_stdout_stderr") targets = [ t for so, t in stdout_and_targets ] for (perm, target) in zip(perms, targets) : dic.setdefault(len(perm), []).append([target,perm]) else : for i_perm, perm in enumerate(perms): if i_perm%500==0: print >> out, " ...perm %d of %d"%(i_perm, len(perms)) selections = tls_group_selections(groups, perm) target = 0 for selection in selections: mo = tls_refinery( u_cart = u_cart, u_iso = u_iso, sites_cart = sites_cart, selection = selection) target += mo.f dic.setdefault(len(perm), []).append([target,perm]) #print " perm %d of %d: target=%8.3f (TLS groups: %s), permutation:"%( # i_perm, len(perms),target,len(perm)),perm print >> out, " Best fits:" print >> out, " No. of Targets" print >> out, " groups best rand.pick diff. score permutation" score_best = -1.e+9 perm_choice = None for k, v in zip(dic.keys(),dic.values()): t_best = v[0][0] perm_best = v[0][1] for v_ in v: if(v_[0]<t_best): t_best = v_[0] perm_best = v_[1] if(u_cart is not None): u_cart_ = u_cart.select(chain_selection) else: u_cart_ = None if(u_iso is not None): u_iso_ = u_iso.select(chain_selection) else: u_iso_ = None r = tls_refinery_random_groups( u_cart = u_cart_, u_iso = u_iso_, sites_cart = sites_cart.select(chain_selection), n_groups = k) score = (r-t_best)/(r+t_best)*100. print >> out, " %3d %6.3f %6.3f %6.2f %6.3f"%( k,t_best, r, r-t_best, score), perm_best if(score > score_best): score_best = score perm_choice = perm_best[:] # chains_and_permutations.append([crs[0],perm_choice]) chains_and_atom_selection_strings.append([crs[0], permutations_as_atom_selection_string(groups, perm_choice)]) # if (pdb_inp is not None) and (not ignore_pdb_header_groups) : external_tls_selections = external_tls( pdb_inp = pdb_inp, pdb_hierarchy = pdb_hierarchy, sites_cart = sites_cart, u_iso = u_iso, out = out) print_statistics.make_header("SUMMARY", out=out) #print "Optimal TLS groups:" #for chain_and_permutation in chains_and_permutations: # print chain_and_permutation #print print >> out, "TLS atom selections for phenix.refine:" groups_out = cStringIO.StringIO() selection_strings = [] print >> groups_out, "refinement.refine.adp {" for r in chains_and_atom_selection_strings: prefix = "chain '%s'"%r[0] if(len(r[1])>0 and len(r[1:])>0): prefix += " and " for r_ in r[1:]: for r__ in r_: if(len(r__)>0): group_selection = prefix+"(%s)"%r__ print >> groups_out, " tls = \"%s\"" % group_selection selection_strings.append("%s" % group_selection) else: print >> groups_out, " tls = \"%s\"" % prefix selection_strings.append("%s" % prefix) print >> groups_out, "}" print >> out, groups_out.getvalue() print >> out #XXX if 0: merge_groups_by_connectivity( pdb_hierarchy = pdb_hierarchy, xray_structure = xray_structure, selection_strings = selection_strings) #XXX if(len(selection_strings)>0): total_target = total_score( pdb_hierarchy = pdb_hierarchy, sites_cart = sites_cart, u_iso = u_iso, selection_strings = selection_strings) print >> out, "Overall best total target for automatically found groups: %10.1f"%total_target print >> out if (return_as_list) : return selection_strings else : return groups_out.getvalue()
def run(fmodel, geometry_restraints_manager, pdb_hierarchy, solvent_selection, optimize_hd = False, log = None, params = None): if(log is None): log = sys.stdout if(params is None): params = master_params().extract() print_statistics.make_sub_header(text="Fitting sidechains", out=log) mon_lib_srv = mmtbx.monomer_library.server.server() if(params.use_dihedral_restraints): sel = flex.bool(fmodel.xray_structure.scatterers().size(), True) geometry_restraints_manager = geometry_restraints_manager.select(sel) geometry_restraints_manager.remove_dihedrals_in_place(sel) restraints_manager = mmtbx.restraints.manager( geometry = geometry_restraints_manager, normalization = True) model = mmtbx.model.manager( restraints_manager = restraints_manager, xray_structure = fmodel.xray_structure, pdb_hierarchy = pdb_hierarchy) backbone_selections = model.backbone_selections() if(params.ignore_water_when_move_sidechains): selection = ~model.solvent_selection() else: selection = flex.bool(model.xray_structure.scatterers().size(), True) selection &= backbone_selections fmt = "Macro-cycle %2d: r_work=%6.4f r_free=%6.4f" print >> log, fmt%(0, fmodel.r_work(), fmodel.r_free()) for macro_cycle in range(1,params.number_of_macro_cycles+1): target_map_data, fft_map_1 = get_map_data(fmodel = fmodel, map_type = params.target_map, exclude_free_r_reflections = params.exclude_free_r_reflections) model_map_data,fft_map_2 = get_map_data(fmodel = fmodel, map_type = params.model_map) residual_map_data,fft_map_3 = get_map_data(fmodel = fmodel, map_type = params.residual_map, exclude_free_r_reflections = params.exclude_free_r_reflections) if(params.filter_residual_map_value is not None): #XXX use filtering.... map_sel = flex.abs(residual_map_data) < params.filter_residual_map_value residual_map_data = residual_map_data.set_selected(map_sel, 0) if(params.filter_2fofc_map is not None): map_sel = flex.abs(target_map_data) < params.filter_2fofc_map target_map_data = target_map_data.set_selected(map_sel, 0) rsr_manager = refiner( pdb_hierarchy = pdb_hierarchy, target_map = target_map_data, geometry_restraints_manager = geometry_restraints_manager, real_space_target_weight = params.residue_iteration.real_space_refine_target_weight, real_space_gradients_delta = fmodel.f_obs().d_min()/4, max_iterations = params.residue_iteration.real_space_refine_max_iterations) residue_rsr_monitor = residue_iteration( pdb_hierarchy = pdb_hierarchy, xray_structure = fmodel.xray_structure, selection = selection, target_map_data = target_map_data, model_map_data = model_map_data, residual_map_data = residual_map_data, mon_lib_srv = mon_lib_srv, rsr_manager = rsr_manager, optimize_hd = optimize_hd, params = params.residue_iteration, log = log) fmodel.update_xray_structure(update_f_calc=True, update_f_mask=True) print >> log, "1:", fmt%(macro_cycle, fmodel.r_work(), fmodel.r_free()) del target_map_data, model_map_data, residual_map_data, fft_map_1, fft_map_2, fft_map_3 if(params.validate_change): validate_changes(fmodel = fmodel, residue_rsr_monitor = residue_rsr_monitor, validate_method=None, log = log)
def run(args, crystal_symmetry=None, ncs_object=None, pdb_hierarchy=None, map_data=None, lower_bounds=None, upper_bounds=None, write_output_files=True, log=None): h = "phenix.map_box: extract box with model and map around selected atoms" if(log is None): log = sys.stdout print_statistics.make_header(h, out=log) default_message="""\ %s. Usage: phenix.map_box model.pdb map_coefficients.mtz selection="chain A and resseq 1:10" or phenix.map_box map.ccp4 density_select=True Parameters:"""%h if(len(args) == 0 and not pdb_hierarchy): print default_message master_phil.show(prefix=" ") return inputs = mmtbx.utils.process_command_line_args(args = args, cmd_cs=crystal_symmetry, master_params = master_phil) params = inputs.params.extract() master_phil.format(python_object=params).show(out=log) # Overwrite params with parameters in call if available if lower_bounds: params.lower_bounds=lower_bounds if upper_bounds: params.upper_bounds=upper_bounds # PDB file if params.pdb_file and not inputs.pdb_file_names and not pdb_hierarchy: inputs.pdb_file_names=[params.pdb_file] if(len(inputs.pdb_file_names)!=1 and not params.density_select and not pdb_hierarchy and not params.keep_map_size and not params.upper_bounds and not params.extract_unique): raise Sorry("PDB file is needed unless extract_unique, "+ "density_select, keep_map_size \nor bounds are set .") if (len(inputs.pdb_file_names)!=1 and not pdb_hierarchy and \ (params.mask_atoms or params.soft_mask )): raise Sorry("PDB file is needed for mask_atoms or soft_mask") if (params.density_select and params.keep_map_size): raise Sorry("Cannot set both density_select and keep_map_size") if (params.density_select and params.upper_bounds): raise Sorry("Cannot set both density_select and bounds") if (params.keep_map_size and params.upper_bounds): raise Sorry("Cannot set both keep_map_size and bounds") if (params.upper_bounds and not params.lower_bounds): raise Sorry("Please set lower_bounds if you set upper_bounds") if (params.extract_unique and not params.resolution): raise Sorry("Please set resolution for extract_unique") if (write_output_files) and ("mtz" in params.output_format) and ( (params.keep_origin) and (not params.keep_map_size)): raise Sorry("Please set output_format=ccp4 to skip mtz or set "+\ "keep_origin=False or keep_map_size=True") if params.keep_input_unit_cell_and_grid and ( (params.output_unit_cell_grid is not None ) or (params.output_unit_cell is not None ) ): raise Sorry("If you set keep_input_unit_cell_and_grid then you cannot "+\ "set \noutput_unit_cell_grid or output_unit_cell") if params.output_origin_grid_units is not None and params.keep_origin: params.keep_origin=False print "Setting keep_origin=False as output_origin_grid_units is set" print_statistics.make_sub_header("pdb model", out=log) if len(inputs.pdb_file_names)>0: pdb_inp = iotbx.pdb.input(file_name=inputs.pdb_file_names[0]) pdb_hierarchy = pdb_inp.construct_hierarchy() if pdb_hierarchy: pdb_atoms = pdb_hierarchy.atoms() pdb_atoms.reset_i_seq() else: pdb_hierarchy=None # Map or map coefficients map_coeff = None input_unit_cell_grid=None input_unit_cell=None if (not map_data): # read first mtz file if ( (len(inputs.reflection_file_names) > 0) or (params.map_coefficients_file is not None) ): # file in phil takes precedent if (params.map_coefficients_file is not None): if (len(inputs.reflection_file_names) == 0): inputs.reflection_file_names.append(params.map_coefficients_file) else: inputs.reflection_file_names[0] = params.map_coefficients_file map_coeff = reflection_file_utils.extract_miller_array_from_file( file_name = inputs.reflection_file_names[0], label = params.label, type = "complex", log = log) if not crystal_symmetry: crystal_symmetry=map_coeff.crystal_symmetry() fft_map = map_coeff.fft_map(resolution_factor=params.resolution_factor) fft_map.apply_sigma_scaling() map_data = fft_map.real_map_unpadded() map_or_map_coeffs_prefix=os.path.basename( inputs.reflection_file_names[0][:-4]) # or read CCP4 map elif ( (inputs.ccp4_map is not None) or (params.ccp4_map_file is not None) ): if (params.ccp4_map_file is not None): af = any_file(params.ccp4_map_file) if (af.file_type == 'ccp4_map'): inputs.ccp4_map = af.file_content inputs.ccp4_map_file_name = params.ccp4_map_file print_statistics.make_sub_header("CCP4 map", out=log) ccp4_map = inputs.ccp4_map ccp4_map.show_summary(prefix=" ",out=log) if not crystal_symmetry: crystal_symmetry=ccp4_map.crystal_symmetry() map_data = ccp4_map.data #map_data() input_unit_cell_grid=ccp4_map.unit_cell_grid input_unit_cell=ccp4_map.unit_cell_parameters if inputs.ccp4_map_file_name.endswith(".ccp4"): map_or_map_coeffs_prefix=os.path.basename( inputs.ccp4_map_file_name[:-5]) else: map_or_map_coeffs_prefix=os.path.basename( inputs.ccp4_map_file_name[:-4]) else: # have map_data map_or_map_coeffs_prefix=None if params.output_origin_grid_units is not None: origin_to_match=tuple(params.output_origin_grid_units) else: origin_to_match=None if origin_to_match: sc=[] for x,o,a in zip(crystal_symmetry.unit_cell().parameters()[:3], origin_to_match, map_data.all()): sc.append(-x*o/a) shift_cart_for_origin_to_match=tuple(sc) else: origin_to_match=None shift_cart_for_origin_to_match=None if crystal_symmetry and not inputs.crystal_symmetry: inputs.crystal_symmetry=crystal_symmetry # final check that map_data exists if(map_data is None): raise Sorry("Map or map coefficients file is needed.") if len(inputs.pdb_file_names)>0: output_prefix=os.path.basename(inputs.pdb_file_names[0])[:-4] else: output_prefix=map_or_map_coeffs_prefix if not pdb_hierarchy: # get an empty hierarchy from cctbx.array_family import flex pdb_hierarchy=iotbx.pdb.input( source_info='',lines=flex.split_lines('')).construct_hierarchy() xray_structure = pdb_hierarchy.extract_xray_structure( crystal_symmetry=inputs.crystal_symmetry) xray_structure.show_summary(f=log) # selection = pdb_hierarchy.atom_selection_cache().selection( string = params.selection) if selection.size(): print_statistics.make_sub_header("atom selection", out=log) print >> log, "Selection string: selection='%s'"%params.selection print >> log, \ " selects %d atoms from total %d atoms."%(selection.count(True), selection.size()) sites_cart_all = xray_structure.sites_cart() sites_cart = sites_cart_all.select(selection) selection = xray_structure.selection_within( radius = params.selection_radius, selection = selection) if not ncs_object: from mmtbx.ncs.ncs import ncs ncs_object=ncs() if params.symmetry_file: ncs_object.read_ncs(params.symmetry_file,log=log) print >>log,"Total of %s operators read" %(ncs_object.max_operators()) if not ncs_object or ncs_object.max_operators()<1: print >>log,"No symmetry available" if ncs_object: n_ops=max(1,ncs_object.max_operators()) else: n_ops=1 # Get sequence if extract_unique is set sequence=None if params.extract_unique: if params.sequence_file: if n_ops > 1: # get unique part of sequence and multiply remove_duplicates=True else: remove_duplicates=False from iotbx.bioinformatics import get_sequences sequence=n_ops * (" ".join(get_sequences(file_name=params.sequence_file, remove_duplicates=remove_duplicates))) if sequence and not params.molecular_mass: # get molecular mass from sequence from iotbx.bioinformatics import text_from_chains_matching_chain_type if params.chain_type in [None,'PROTEIN']: n_protein=len(text_from_chains_matching_chain_type( text=sequence,chain_type='PROTEIN')) else: n_protein=0 if params.chain_type in [None,'RNA']: n_rna=len(text_from_chains_matching_chain_type( text=sequence,chain_type='RNA')) else: n_rna=0 if params.chain_type in [None,'DNA']: n_dna=len(text_from_chains_matching_chain_type( text=sequence,chain_type='DNA')) else: n_dna=0 params.molecular_mass=n_protein*110+(n_rna+n_dna)*330 elif not params.molecular_mass: raise Sorry("Need a sequence file or molecular mass for extract_unique") else: molecular_mass=None # if params.density_select: print_statistics.make_sub_header( "Extracting box around selected density and writing output files", out=log) else: print_statistics.make_sub_header( "Extracting box around selected atoms and writing output files", out=log) # if params.value_outside_atoms=='mean': print >>log,"\nValue outside atoms mask will be set to mean inside mask" if params.get_half_height_width and params.density_select: print >>log,"\nHalf width at half height will be used to id boundaries" if params.soft_mask and sites_cart_all.size()>0: print >>log,"\nSoft mask will be applied to model-based mask" if params.keep_map_size: print >>log,"\nEntire map will be kept (not cutting out region)" if params.restrict_map_size: print >>log,"\nOutput map will be within input map" if params.lower_bounds and params.upper_bounds: print >>log,"Bounds for cut out map are (%s,%s,%s) to (%s,%s,%s)" %( tuple(list(params.lower_bounds)+list(params.upper_bounds))) box = mmtbx.utils.extract_box_around_model_and_map( xray_structure = xray_structure, map_data = map_data.as_double(), box_cushion = params.box_cushion, selection = selection, density_select = params.density_select, threshold = params.density_select_threshold, get_half_height_width = params.get_half_height_width, mask_atoms = params.mask_atoms, soft_mask = params.soft_mask, soft_mask_radius = params.soft_mask_radius, mask_atoms_atom_radius = params.mask_atoms_atom_radius, value_outside_atoms = params.value_outside_atoms, keep_map_size = params.keep_map_size, restrict_map_size = params.restrict_map_size, lower_bounds = params.lower_bounds, upper_bounds = params.upper_bounds, extract_unique = params.extract_unique, chain_type = params.chain_type, sequence = sequence, solvent_content = params.solvent_content, molecular_mass = params.molecular_mass, resolution = params.resolution, ncs_object = ncs_object, symmetry = params.symmetry, ) ph_box = pdb_hierarchy.select(selection) ph_box.adopt_xray_structure(box.xray_structure_box) box.hierarchy=ph_box if (inputs and # XXX fix or remove this inputs.crystal_symmetry and inputs.ccp4_map and inputs.crystal_symmetry.unit_cell().parameters() and inputs.ccp4_map.unit_cell_parameters ) and ( inputs.crystal_symmetry.unit_cell().parameters() != inputs.ccp4_map.unit_cell_parameters): print >>log,"\nNOTE: Mismatch of unit cell parameters from CCP4 map:" print >>log,"Unit cell from CCP4 map 'unit cell parameters': "+\ "%.1f, %.1f, %.1f, %.1f, %.1f, %.1f)" %tuple( inputs.ccp4_map.unit_cell_parameters) print >>log,"Unit cell from CCP4 map 'map grid': "+\ "%.1f, %.1f, %.1f, %.1f, %.1f, %.1f)" %tuple( inputs.crystal_symmetry.unit_cell().parameters()) print >>log,"\nInterpreting this as the 'unit cell parameters' was "+\ "original map \ndimension and 'map grid' is the "+\ "portion actually in the map that was supplied here.\n" box.unit_cell_parameters_from_ccp4_map=inputs.ccp4_map.unit_cell_parameters box.unit_cell_parameters_deduced_from_map_grid=\ inputs.crystal_symmetry.unit_cell().parameters() else: box.unit_cell_parameters_from_ccp4_map=None box.unit_cell_parameters_deduced_from_map_grid=None if box.pdb_outside_box_msg: print >> log, box.pdb_outside_box_msg # NOTE: box object is always shifted to place origin at (0,0,0) # NOTE ON ORIGIN SHIFTS: The shifts are applied locally here. The box # object is not affected and always has the origin at (0,0,0) # output_box is copy of box with shift_cart corresponding to the output # files. Normally this is the same as the original shift_cart. However # if user has specified a new output origin it will differ. # For output files ONLY: # keep_origin==False leave origin at (0,0,0) # keep_origin==True: we shift everything back to where it was, # output_origin_grid_units=10,10,10: output origin is at (10,10,10) # ncs_object is original # box.ncs_object is shifted by shift_cart # output_box.ncs_object is shifted back by -new shift_cart # Additional note on output unit_cell and grid_units. # The ccp4-style output map can specify the unit cell and grid units # corresponding to that cell. This can be separate from the origin and # number of grid points in the map as written. If specified, write these # out to the output ccp4 map and also use this unit cell for writing # any output PDB files from copy import deepcopy output_box=deepcopy(box) # won't use box below here except to return it print >>log,"\nBox cell dimensions: (%.2f, %.2f, %.2f) A" %( box.box_crystal_symmetry.unit_cell().parameters()[:3]) if box.shift_cart: print>>log,"Working origin moved from grid position of"+\ ": (%d, %d, %d) to (0,0,0) " %( tuple(box.origin_shift_grid_units(reverse=True))) print>>log,"Working origin moved from coordinates of:"+\ " (%.2f, %.2f, %.2f) A to (0,0,0)\n" %( tuple(-col(box.shift_cart))) if (params.keep_origin): print >>log,"\nRestoring original position for output files" print >>log,"Origin will be at grid position of"+\ ": (%d, %d, %d) " %( tuple(box.origin_shift_grid_units(reverse=True))) print >>log,\ "\nOutput files will be in same location as original", if not params.keep_map_size: print >>log,"just cut out." else: print >>log,"keeping entire map" print >>log,"Note that output maps are only valid in the cut out region.\n" else: if origin_to_match: output_box.shift_cart=shift_cart_for_origin_to_match if params.output_origin_grid_units: print >>log,"Output map origin to be shifted to match target" print >>log, "Placing origin at grid point (%s, %s, %s)" %( origin_to_match)+"\n"+ \ "Final coordinate shift for output files: (%.2f,%.2f,%.2f) A\n" %( tuple(col(output_box.shift_cart)-col(box.shift_cart))) elif box.shift_cart: output_box.shift_cart=(0,0,0) # not shifting back print >>log,"Final origin will be at (0,0,0)" print >>log,\ "Final coordinate shift for output files: (%.2f,%.2f,%.2f) A\n" %( tuple(col(output_box.shift_cart)-col(box.shift_cart))) else: print >>log,\ "\nOutput files are in same location as original and origin "+\ "is at (0,0,0)\n" ph_output_box_output_location = ph_box.deep_copy() if output_box.shift_cart: # shift coordinates and NCS back by shift_cart # NOTE output_box.shift_cart could be different than box.shift_cart if # there is a target position for the origin and it is not the same as the # original origin. sites_cart = output_box.shift_sites_cart_back( output_box.xray_structure_box.sites_cart()) xrs_offset = ph_output_box_output_location.extract_xray_structure( crystal_symmetry=output_box.xray_structure_box.crystal_symmetry() ).replace_sites_cart(new_sites = sites_cart) ph_output_box_output_location.adopt_xray_structure(xrs_offset) if output_box.ncs_object: output_box.ncs_object=output_box.ncs_object.coordinate_offset( tuple(-col(output_box.shift_cart))) shift_back=True else: shift_back=False if params.keep_input_unit_cell_and_grid and \ (input_unit_cell_grid is not None) and \ (input_unit_cell is not None): params.output_unit_cell=input_unit_cell params.output_unit_cell_grid=input_unit_cell_grid print >>log,"Setting output unit cell parameters and unit cell grid to"+\ " match\ninput map file" if params.output_unit_cell: # Set output unit cell parameters from cctbx import crystal output_crystal_symmetry=crystal.symmetry( unit_cell=params.output_unit_cell, space_group="P1") output_unit_cell=output_crystal_symmetry.unit_cell() print >>log,\ "Output unit cell set to: %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)" %tuple( output_crystal_symmetry.unit_cell().parameters()) else: output_crystal_symmetry=None # ============= Check/set output unit cell grid and cell parameters ======= if params.output_unit_cell_grid or output_crystal_symmetry: if params.output_unit_cell_grid: output_unit_cell_grid=params.output_unit_cell_grid else: output_unit_cell_grid=output_box.map_box.all() print >>log,\ "Output unit cell grid set to: (%s, %s, %s)" %tuple( output_unit_cell_grid) expected_output_abc=[] box_spacing=[] output_spacing=[] box_abc=output_box.xray_structure_box.\ crystal_symmetry().unit_cell().parameters()[:3] if output_crystal_symmetry: output_abc=output_crystal_symmetry.unit_cell().parameters()[:3] else: output_abc=[None,None,None] for a_box,a_output,n_box,n_output in zip( box_abc, output_abc, output_box.map_box.all(), output_unit_cell_grid): expected_output_abc.append(a_box*n_output/n_box) box_spacing.append(a_box/n_box) if output_crystal_symmetry: output_spacing.append(a_output/n_output) else: output_spacing.append(a_box/n_box) if output_crystal_symmetry: # make sure it is compatible... r0=expected_output_abc[0]/output_abc[0] r1=expected_output_abc[1]/output_abc[1] r2=expected_output_abc[2]/output_abc[2] from libtbx.test_utils import approx_equal if not approx_equal(r0,r1,eps=0.001) or not approx_equal(r0,r2,eps=0.001): print >>log,"WARNING: output_unit_cell and cell_grid will "+\ "change ratio of grid spacing.\nOld spacings: "+\ "(%.2f, %.2f, %.2f) A " %(tuple(box_spacing))+\ "\nNew spacings: (%.2f, %.2f, %.2f) A \n" %(tuple(output_spacing)) else: output_abc=expected_output_abc from cctbx import crystal output_crystal_symmetry=crystal.symmetry( unit_cell=list(output_abc)+[90,90,90], space_group="P1") print >>log, \ "Output unit cell will be: (%.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n"%( tuple(output_crystal_symmetry.unit_cell().parameters())) else: output_unit_cell_grid = map_data=output_box.map_box.all() output_crystal_symmetry=output_box.xray_structure_box.crystal_symmetry() # ========== Done check/set output unit cell grid and cell parameters ===== if write_output_files: # Write PDB file if ph_box.overall_counts().n_residues>0: if(params.output_file_name_prefix is None): file_name = "%s_box.pdb"%output_prefix else: file_name = "%s.pdb"%params.output_file_name_prefix ph_output_box_output_location.write_pdb_file(file_name=file_name, crystal_symmetry = output_crystal_symmetry) print >> log, "Writing boxed PDB with box unit cell to %s" %( file_name) # Write NCS file if NCS if output_box.ncs_object and output_box.ncs_object.max_operators()>0: if(params.output_file_name_prefix is None): output_symmetry_file = "%s_box.ncs_spec"%output_prefix else: output_symmetry_file = "%s.ncs_spec"%params.output_file_name_prefix output_box.ncs_object.format_all_for_group_specification( file_name=output_symmetry_file) print >>log,"\nWriting symmetry to %s" %( output_symmetry_file) # Write ccp4 map. if("ccp4" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.ccp4"%output_prefix else: file_name = "%s.ccp4"%params.output_file_name_prefix output_box.write_ccp4_map(file_name=file_name, output_crystal_symmetry=output_crystal_symmetry, output_unit_cell_grid=output_unit_cell_grid, shift_back=shift_back) print >> log, "Writing boxed map "+\ "to CCP4 formatted file: %s"%file_name # Write xplor map. Shift back if keep_origin=True if("xplor" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.xplor"%output_prefix else: file_name = "%s.xplor"%params.output_file_name_prefix output_box.write_xplor_map(file_name=file_name, output_crystal_symmetry=output_crystal_symmetry, output_unit_cell_grid=output_unit_cell_grid, shift_back=shift_back,) print >> log, "Writing boxed map "+\ "to X-plor formatted file: %s"%file_name # Write mtz map coeffs. Shift back if keep_origin=True if("mtz" in params.output_format): if(params.output_file_name_prefix is None): file_name = "%s_box.mtz"%output_prefix else: file_name = "%s.mtz"%params.output_file_name_prefix print >> log, "Writing map coefficients "+\ "to MTZ file: %s"%file_name if(map_coeff is not None): d_min = map_coeff.d_min() elif params.resolution is not None: d_min = params.resolution else: d_min = maptbx.d_min_from_map(map_data=output_box.map_box, unit_cell=output_box.xray_structure_box.unit_cell()) output_box.map_coefficients(d_min=d_min, resolution_factor=params.resolution_factor, file_name=file_name, shift_back=shift_back) print >> log return box
def __init__(self, fmodel, selections=None, params=None, r_initial=None, t_initial=None, bss=None, log=None, monitors=None): global time_rigid_body_total self.params = params save_original_target_name = fmodel.target_name save_bss_anisotropic_scaling = None if (bss is not None): save_bss_anisotropic_scaling = bss.anisotropic_scaling timer_rigid_body_total = user_plus_sys_time() save_r_work = fmodel.r_work() save_r_free = fmodel.r_free() save_xray_structure = fmodel.xray_structure.deep_copy_scatterers() if (log is None): log = sys.stdout if (selections is None): selections = [] selections.append( flex.bool(fmodel.xray_structure.scatterers().size(), True).iselection()) else: assert len(selections) > 0 fmodel.xray_structure.scatterers().flags_set_grads(state=False) fmodel.xray_structure.scatterers().flags_set_grad_site( iselection=flex.bool(fmodel.xray_structure.scatterers().size(), True).iselection()) self.total_rotation = [] self.total_translation = [] for item in selections: self.total_rotation.append(flex.double(3, 0)) self.total_translation.append(flex.double(3, 0)) if (r_initial is None): r_initial = [] for item in selections: r_initial.append(flex.double(3, 0)) if (t_initial is None): t_initial = [] for item in selections: t_initial.append(flex.double(3, 0)) fmodel_copy = fmodel.deep_copy() if (fmodel_copy.mask_params is not None): fmodel_copy.mask_params.verbose = -1 d_mins, target_names = split_resolution_range( d_spacings=fmodel_copy.f_obs_work().d_spacings().data(), n_bodies=len(selections), target=params.target, target_auto_switch_resolution=params.target_auto_switch_resolution, n_ref_first=params.min_number_of_reflections, multi_body_factor_n_ref_first=params.multi_body_factor, d_low=params.max_low_high_res_limit, d_high=params.high_resolution, number_of_zones=params.number_of_zones, zone_exponent=params.zone_exponent, log=log) print(file=log) if (fmodel.target_name != target_names[0]): fmodel.update(target_name=target_names[0]) self.show(fmodel=fmodel, r_mat=self.total_rotation, t_vec=self.total_translation, header="Start", out=log) if (params.number_of_zones == 1 or monitors is None): monitors_call_back_handler = None else: monitors_call_back_handler = monitors.call_back_handler if (monitors_call_back_handler is not None): monitors_call_back_handler(monitor=None, model=None, fmodel=fmodel, method="rigid_body") for res, target_name in zip(d_mins, target_names): xrs = fmodel_copy.xray_structure.deep_copy_scatterers() fmodel_copy = fmodel.resolution_filter(d_min=res) if (fmodel_copy.target_name != target_name): fmodel_copy.update(target_name=target_name) d_max_min = fmodel_copy.f_obs_work().d_max_min() line = "Refinement at resolution: "+\ str("%7.2f"%d_max_min[0]).strip() + " - " \ + str("%6.2f"%d_max_min[1]).strip() \ + " target=" + fmodel_copy.target_name print_statistics.make_sub_header(line, out=log) fmodel_copy.update_xray_structure(xray_structure=xrs, update_f_calc=True) rworks = flex.double() if (len(d_mins) == 1): n_rigid_body_minimizer_cycles = 1 else: n_rigid_body_minimizer_cycles = min(int(res), 4) for i_macro_cycle in range(n_rigid_body_minimizer_cycles): if (bss is not None and params.bulk_solvent_and_scale): if (fmodel_copy.f_obs().d_min() > 3.0): bss.anisotropic_scaling = False fast = True if (bss.mode == "slow"): fast = False fmodel_copy.update_all_scales(update_f_part1=False, params=bss, fast=fast, log=log, remove_outliers=False, optimize_mask=False, refine_hd_scattering=False) if (fmodel_copy.f_obs().d_min() > 3.0): assert save_bss_anisotropic_scaling is not None bss.anisotropic_scaling = save_bss_anisotropic_scaling bss.minimization_b_cart = save_bss_anisotropic_scaling minimized = rigid_body_minimizer( fmodel=fmodel_copy, selections=selections, r_initial=r_initial, t_initial=t_initial, refine_r=params.refine_rotation, refine_t=params.refine_translation, max_iterations=params.max_iterations, euler_angle_convention=params.euler_angle_convention, lbfgs_maxfev=params. lbfgs_line_search_max_function_evaluations) rotation_matrices = [] translation_vectors = [] for i in range(len(selections)): self.total_rotation[i] += flex.double(minimized.r_min[i]) self.total_translation[i] += flex.double( minimized.t_min[i]) rot_obj = scitbx.rigid_body.euler( phi=minimized.r_min[i][0], psi=minimized.r_min[i][1], the=minimized.r_min[i][2], convention=params.euler_angle_convention) rotation_matrices.append(rot_obj.rot_mat()) translation_vectors.append(minimized.t_min[i]) new_xrs = apply_transformation( xray_structure=minimized.fmodel.xray_structure, rotation_matrices=rotation_matrices, translation_vectors=translation_vectors, selections=selections) fmodel_copy.update_xray_structure(xray_structure=new_xrs, update_f_calc=True, update_f_mask=True) rwork = minimized.fmodel.r_work() rfree = minimized.fmodel.r_free() assert approx_equal(rwork, fmodel_copy.r_work()) fmodel.update_xray_structure( xray_structure=fmodel_copy.xray_structure, update_f_calc=True, update_f_mask=True) if (bss is not None and params.bulk_solvent_and_scale): fast = True if (bss.mode == "slow"): fast = False fmodel_copy.update_all_scales(update_f_part1=False, params=bss, fast=fast, log=log, remove_outliers=False, optimize_mask=False, refine_hd_scattering=False) self.show(fmodel=fmodel, r_mat=self.total_rotation, t_vec=self.total_translation, header="Rigid body refinement", out=log) if (monitors_call_back_handler is not None): monitors_call_back_handler(monitor=None, model=None, fmodel=fmodel, method="rigid_body") if (bss is not None and params.bulk_solvent_and_scale): fast = True if (bss.mode == "slow"): fast = False fmodel_copy.update_all_scales(update_f_part1=False, params=bss, fast=fast, log=log, remove_outliers=False, optimize_mask=False, refine_hd_scattering=False) print(file=log) self.show(fmodel=fmodel, r_mat=self.total_rotation, t_vec=self.total_translation, header="Rigid body end", out=log) print(file=log) self.evaluate_after_end(fmodel, save_r_work, save_r_free, save_xray_structure, log) self.fmodel = fmodel self.fmodel.update(target_name=save_original_target_name) time_rigid_body_total += timer_rigid_body_total.elapsed()
def run(args, crystal_symmetry=None, pdb_hierarchy=None, map_data=None, write_output_files=True, log=None): h = "phenix.map_box: extract box with model and map around selected atoms" if (log is None): log = sys.stdout print_statistics.make_header(h, out=log) default_message = """\ %s. Usage: phenix.map_box model.pdb map_coefficients.mtz selection="chain A and resseq 1:10" or phenix.map_box map.ccp4 density_select=True Parameters:""" % h if (len(args) == 0 and not pdb_hierarchy): print default_message master_phil.show(prefix=" ") return inputs = mmtbx.utils.process_command_line_args(args=args, cmd_cs=crystal_symmetry, master_params=master_phil) params = inputs.params.extract() # PDB file if params.pdb_file and not inputs.pdb_file_names and not pdb_hierarchy: inputs.pdb_file_names = [params.pdb_file] if (len(inputs.pdb_file_names) != 1 and not params.density_select and not pdb_hierarchy): raise Sorry("PDB file is needed unless density_select is set.") print_statistics.make_sub_header("pdb model", out=log) if len(inputs.pdb_file_names) > 0: pdb_inp = iotbx.pdb.input(file_name=inputs.pdb_file_names[0]) pdb_hierarchy = pdb_inp.construct_hierarchy() if pdb_hierarchy: pdb_atoms = pdb_hierarchy.atoms() pdb_atoms.reset_i_seq() else: pdb_hierarchy = None # Map or map coefficients map_coeff = None if (not map_data): # read first mtz file if ((len(inputs.reflection_file_names) > 0) or (params.map_coefficients_file is not None)): # file in phil takes precedent if (params.map_coefficients_file is not None): if (len(inputs.reflection_file_names) == 0): inputs.reflection_file_names.append( params.map_coefficients_file) else: inputs.reflection_file_names[ 0] = params.map_coefficients_file map_coeff = reflection_file_utils.extract_miller_array_from_file( file_name=inputs.reflection_file_names[0], label=params.label, type="complex", log=log) fft_map = map_coeff.fft_map( resolution_factor=params.resolution_factor) fft_map.apply_sigma_scaling() map_data = fft_map.real_map_unpadded() map_or_map_coeffs_prefix = os.path.basename( inputs.reflection_file_names[0][:-4]) # or read CCP4 map elif ((inputs.ccp4_map is not None) or (params.ccp4_map_file is not None)): if (params.ccp4_map_file is not None): af = any_file(params.ccp4_map_file) if (af.file_type == 'ccp4_map'): inputs.ccp4_map = af.file_content inputs.ccp4_map_file_name = params.ccp4_map_file print_statistics.make_sub_header("CCP4 map", out=log) ccp4_map = inputs.ccp4_map ccp4_map.show_summary(prefix=" ", out=log) map_data = ccp4_map.data #map_data() if inputs.ccp4_map_file_name.endswith(".ccp4"): map_or_map_coeffs_prefix = os.path.basename( inputs.ccp4_map_file_name[:-5]) else: map_or_map_coeffs_prefix = os.path.basename( inputs.ccp4_map_file_name[:-4]) else: # have map_data map_or_map_coeffs_prefix = None # final check that map_data exists if (map_data is None): raise Sorry("Map or map coefficients file is needed.") if len(inputs.pdb_file_names) > 0: output_prefix = os.path.basename(inputs.pdb_file_names[0])[:-4] else: output_prefix = map_or_map_coeffs_prefix if not pdb_hierarchy: # get an empty hierarchy from cctbx.array_family import flex pdb_hierarchy = iotbx.pdb.input( source_info='', lines=flex.split_lines('')).construct_hierarchy() xray_structure = pdb_hierarchy.extract_xray_structure( crystal_symmetry=inputs.crystal_symmetry) xray_structure.show_summary(f=log) # selection = pdb_hierarchy.atom_selection_cache().selection( string=params.selection) if selection.size(): print_statistics.make_sub_header("atom selection", out=log) print >> log, "Selection string: selection='%s'" % params.selection print >> log, \ " selects %d atoms from total %d atoms."%(selection.count(True), selection.size()) sites_cart_all = xray_structure.sites_cart() sites_cart = sites_cart_all.select(selection) selection = xray_structure.selection_within(radius=params.selection_radius, selection=selection) # if params.density_select: print_statistics.make_sub_header( "Extracting box around selected density and writing output files", out=log) else: print_statistics.make_sub_header( "Extracting box around selected atoms and writing output files", out=log) # if params.value_outside_atoms == 'mean': print >> log, "\nValue outside atoms mask will be set to mean inside mask" if params.get_half_height_width: print >> log, "\nHalf width at half height will be used to id boundaries" box = mmtbx.utils.extract_box_around_model_and_map( xray_structure=xray_structure, map_data=map_data.as_double(), box_cushion=params.box_cushion, selection=selection, density_select=params.density_select, threshold=params.density_select_threshold, get_half_height_width=params.get_half_height_width, mask_atoms=params.mask_atoms, soft_mask=params.soft_mask, soft_mask_radius=params.soft_mask_radius, mask_atoms_atom_radius=params.mask_atoms_atom_radius, value_outside_atoms=params.value_outside_atoms, ) if box.initial_shift_cart: print >> log, "\nInitial coordinate shift will be (%.1f,%.1f,%.1f)\n" % ( box.initial_shift_cart) if box.total_shift_cart: print >> log, "Final coordinate shift: (%.1f,%.1f,%.1f)" % ( box.total_shift_cart) print >> log, "Final cell dimensions: (%.1f,%.1f,%.1f)\n" % ( box.box_crystal_symmetry.unit_cell().parameters()[:3]) if box.pdb_outside_box_msg: print >> log, box.pdb_outside_box_msg ph_box = pdb_hierarchy.select(selection) ph_box.adopt_xray_structure(box.xray_structure_box) box.hierarchy = ph_box if not write_output_files: return box if (params.output_file_name_prefix is None): file_name = "%s_box.pdb" % output_prefix else: file_name = "%s.pdb" % params.output_file_name_prefix ph_box = pdb_hierarchy.select(selection) ph_box.adopt_xray_structure(box.xray_structure_box) ph_box.write_pdb_file( file_name=file_name, crystal_symmetry=box.xray_structure_box.crystal_symmetry()) if ("ccp4" in params.output_format): if (params.output_file_name_prefix is None): file_name = "%s_box.ccp4" % output_prefix else: file_name = "%s.ccp4" % params.output_file_name_prefix print >> log, "writing map to CCP4 formatted file: %s" % file_name box.write_ccp4_map(file_name=file_name) if ("xplor" in params.output_format): if (params.output_file_name_prefix is None): file_name = "%s_box.xplor" % output_prefix else: file_name = "%s.xplor" % params.output_file_name_prefix print >> log, "writing map to X-plor formatted file: %s" % file_name box.write_xplor_map(file_name=file_name) if ("mtz" in params.output_format): if (params.output_file_name_prefix is None): file_name = "%s_box.mtz" % output_prefix else: file_name = "%s.mtz" % params.output_file_name_prefix print >> log, "writing map coefficients to MTZ file: %s" % file_name if (map_coeff is not None): d_min = map_coeff.d_min() else: d_min = maptbx.d_min_from_map( map_data=box.map_box, unit_cell=box.xray_structure_box.unit_cell()) box.map_coefficients(d_min=d_min, resolution_factor=params.resolution_factor, file_name=file_name) if params.ncs_file: if (params.output_file_name_prefix is None): output_ncs_file = "%s_box.ncs_spec" % output_prefix else: output_ncs_file = "%s.ncs_spec" % params.output_file_name_prefix print >> log, "\nOffsetting NCS in %s and writing to %s" % ( params.ncs_file, output_ncs_file) from mmtbx.ncs.ncs import ncs ncs_object = ncs() ncs_object.read_ncs(params.ncs_file, log=log) ncs_object.display_all(log=log) if not ncs_object or ncs_object.max_operators() < 1: print >> log, "Skipping...no NCS available" elif box.total_shift_cart: from scitbx.math import matrix print >>log,"Shifting NCS operators "+\ "based on coordinate shift of (%7.1f,%7.1f,%7.1f)" %( tuple(box.total_shift_cart)) ncs_object = ncs_object.coordinate_offset( coordinate_offset=matrix.col(box.total_shift_cart)) ncs_object.display_all(log=log) ncs_object.format_all_for_group_specification( file_name=output_ncs_file) box.ncs_object = ncs_object else: box.ncs_object = None print >> log return box
def __init__( self, fmodels, model, params, target_weights, macro_cycle, ncs_manager=None, log=None): if log is None: log = sys.stdout # self.ncs_manager = ncs_manager self.nproc = params.main.nproc if self.nproc is Auto: self.nproc = 1 self.verbose = params.den.verbose self.log = log self.fmodels = fmodels self.model = model self.params = params self.target_weights = target_weights self.adp_refinement_manager = None self.macro_cycle = macro_cycle self.tan_b_iso_max = 0 self.random_seed = params.main.random_seed den_manager = model.restraints_manager. \ geometry.den_manager print_statistics.make_header("DEN refinement", out=self.log) pdb_hierarchy = self.model.pdb_hierarchy(sync_with_xray_structure=True) if den_manager.get_n_proxies() == 0: print_statistics.make_sub_header( "DEN restraint nework", out = self.log) den_manager.build_den_proxies(pdb_hierarchy=pdb_hierarchy) den_manager.build_den_restraints() den_manager.show_den_summary( sites_cart=self.model.xray_structure.sites_cart()) if den_manager.params.output_kinemage: den_manager.output_kinemage( self.model.xray_structure.sites_cart()) print_statistics.make_sub_header( "coordinate minimization before annealing", out=self.log) self.minimize(ca_only=self.params.den.minimize_c_alpha_only) self.save_scatterers_local = fmodels.fmodel_xray().\ xray_structure.deep_copy_scatterers().scatterers() #DEN refinement start, turn on if params.den.optimize: grid = den_manager.get_optimization_grid() print >> log, \ "Running DEN torsion optimization on %d processors..." % \ params.main.nproc else: grid = [(params.den.gamma, params.den.weight)] grid_results = [] grid_so = [] if "torsion" in params.den.annealing_type: print >> self.log, "Running torsion simulated annealing" if ( (params.den.optimize) and ( (self.nproc is Auto) or (self.nproc > 1) )): stdout_and_results = easy_mp.pool_map( processes=params.main.nproc, fixed_func=self.try_den_weight_torsion, args=grid, func_wrapper="buffer_stdout_stderr") for so, r in stdout_and_results: if (r is None): raise RuntimeError(("DEN weight optimization failed:"+ "\n%s\nThis is a "+ "serious error; please contact [email protected].") % so) grid_so.append(so) grid_results.append(r) else: for grid_pair in grid: result = self.try_den_weight_torsion( grid_pair=grid_pair) grid_results.append(result) self.show_den_opt_summary_torsion(grid_results) elif "cartesian" in params.den.annealing_type: print >> self.log, "Running Cartesian simulated annealing" if ( (params.den.optimize) and ( (self.nproc is Auto) or (self.nproc > 1) )): stdout_and_results = easy_mp.pool_map( processes=params.main.nproc, fixed_func=self.try_den_weight_cartesian, args=grid, func_wrapper="buffer_stdout_stderr") for so, r in stdout_and_results: if (r is None): raise RuntimeError(("DEN weight optimization failed:"+ "\n%s\nThis is a "+ "serious error; please contact [email protected].") % so) grid_so.append(so) grid_results.append(r) else: for grid_pair in grid: result = self.try_den_weight_cartesian( grid_pair=grid_pair) grid_results.append(result) self.show_den_opt_summary_cartesian(grid_results) else: raise "error in DEN annealing type" low_r_free = 1.0 best_xray_structure = None best_eq_distances = None best_gamma = None best_weight = None best_so_i = None for i, result in enumerate(grid_results): cur_r_free = result[2] if cur_r_free < low_r_free: low_r_free = cur_r_free best_gamma = result[0] best_weight = result[1] best_xray_structure = result[3] best_eq_distances = result[4] best_so_i = i assert best_xray_structure is not None if params.den.optimize: print >> self.log, "\nbest gamma: %.1f" % best_gamma print >> self.log, "best weight: %.1f\n" % best_weight if params.den.verbose: if len(grid_so) >= (best_so_i+1): print >> self.log, "\nBest annealing results:\n" print >> self.log, grid_so[best_so_i] fmodels.fmodel_xray().xray_structure.replace_scatterers( best_xray_structure.deep_copy()) fmodels.update_xray_structure( xray_structure = fmodels.fmodel_xray().xray_structure, update_f_calc = True) utils.assert_xray_structures_equal( x1 = fmodels.fmodel_xray().xray_structure, x2 = model.xray_structure) model.restraints_manager.geometry.\ den_manager.import_eq_distances(eq_distances=best_eq_distances) self.model.restraints_manager.geometry.update_dihedral_ncs_restraints( sites_cart=self.model.xray_structure.sites_cart(), pdb_hierarchy=self.model.pdb_hierarchy(sync_with_xray_structure=True), log=self.log)
def run( fmodel, geometry_restraints_manager, pdb_hierarchy, solvent_selection, secondary_structure=None, params=None, optimize_hd=False, log=None, ): from mmtbx.refinement import print_statistics from mmtbx.secondary_structure import proteins import mmtbx.restraints import mmtbx.model from scitbx.array_family import flex if log is None: log = sys.stdout if params is None: params = master_params().extract() if secondary_structure is None: import mmtbx.secondary_structure secondary_structure = mmtbx.secondary_structure.manager(pdb_hierarchy=pdb_hierarchy) print_statistics.make_sub_header(text="Peptide bond flips", out=log) validator = ramachandran_validator() restraints_manager = mmtbx.restraints.manager(geometry=geometry_restraints_manager, normalization=True) model = mmtbx.model.manager( restraints_manager=restraints_manager, xray_structure=fmodel.xray_structure, pdb_hierarchy=pdb_hierarchy ) backbone_selections = model.backbone_selections() if params.ignore_water_when_flipping: selection = ~model.solvent_selection() else: selection = flex.bool(model.xray_structure.scatterers().size(), True) selection &= backbone_selections fmt = "Macro-cycle %2d: r_work=%6.4f r_free=%6.4f" print >> log, fmt % (0, fmodel.r_work(), fmodel.r_free()) n_mac = params.number_of_macro_cycles if n_mac is None: n_mac = 0 for macro_cycle in range(1, n_mac + 1): target_map_data, fft_map_1 = fit_rotamers.get_map_data(fmodel=fmodel, map_type=params.target_map) model_map_data, fft_map_2 = fit_rotamers.get_map_data(fmodel=fmodel, map_type=params.model_map) residual_map_data, fft_map_3 = fit_rotamers.get_map_data(fmodel=fmodel, map_type=params.residual_map) if params.filter_residual_map_value is not None: # XXX use filtering.... map_sel = flex.abs(residual_map_data) < params.filter_residual_map_value residual_map_data = residual_map_data.set_selected(map_sel, 0) if params.filter_2fofc_map is not None: map_sel = flex.abs(target_map_data) < params.filter_2fofc_map target_map_data = target_map_data.set_selected(map_sel, 0) rsr_manager = fit_rotamers.refiner( pdb_hierarchy=pdb_hierarchy, target_map=target_map_data, geometry_restraints_manager=geometry_restraints_manager, real_space_target_weight=params.residue_iteration.real_space_refine_target_weight, real_space_gradients_delta=fmodel.f_obs().d_min() / 4, max_iterations=params.residue_iteration.real_space_refine_max_iterations, ) secondary_structure.pdb_hierarchy = pdb_hierarchy alpha_selection = secondary_structure.helix_selection(alpha_only=True) if params.skip_approximate_helices: cache = pdb_hierarchy.atom_selection_cache() print >> log, "Looking for roughly helical residues. . ." find_helices = proteins.find_helices_simple(pdb_hierarchy) # find_helices.show(out=log) print >> log, "" ss_params = find_helices.as_restraint_groups() if ss_params is not None: for helix in ss_params.helix: helix_selection = cache.selection(helix.selection) alpha_selection |= helix_selection residue_rsr_monitor = residue_iteration( pdb_hierarchy=pdb_hierarchy, xray_structure=fmodel.xray_structure, selection=selection, alpha_selection=alpha_selection, target_map_data=target_map_data, model_map_data=model_map_data, residual_map_data=residual_map_data, rsr_manager=rsr_manager, params=params.residue_iteration, validator=validator, log=log, ) fmodel.update_xray_structure(update_f_calc=True, update_f_mask=True) print >> log, "1:", fmt % (macro_cycle, fmodel.r_work(), fmodel.r_free()) del target_map_data, model_map_data, residual_map_data, fft_map_1, fft_map_2, fft_map_3 if params.real_space_refine_overall: pass # FIXME this method has completely disappeared... # fit_rotamers.rsr_overall( # model=model, # fmodel=fmodel, # params=params, # optimize_hd=optimize_hd, # macro_cycle=macro_cycle, # log=log) # print >> log, "1:", fmt%(macro_cycle, fmodel.r_work(), fmodel.r_free()) if params.validate_change: fit_rotamers.validate_changes( fmodel=fmodel, residue_rsr_monitor=residue_rsr_monitor, validate_method=validator, log=log ) pdb_hierarchy.atoms().set_xyz(fmodel.xray_structure.sites_cart())