def format_old (self) : s_occ = format_value("%.2f", self.occupancy) s_score = format_value("%.1f", self.score) chis = list(self.chi_angles) return "%s:%s:%s:%s:%s:%s" % (self.id_str(), s_occ, s_score, self.format_chi_angles(pad=True, sep=":"), self.evaluation,self.rotamer_name)
def rescore (self, params, log=None, prefix="") : # FIXME this needs to be rationalized and made consistent with the # rescoring against the original maps if (log is None) : log = null_out() reject = (self.rotamer == "OUTLIER") bad_mc_two_fofc_msg = None for i_seq, atom in enumerate(self.new_hierarchy.atoms()) : name = atom.name.strip() if (name in ["N","C","O","CA", "CB"]) : if (self.two_fofc_values[i_seq] < params.omit_two_fofc_min_mc) : bad_mc_two_fofc_msg = "poor backbone: 2Fo-Fc(%s)=%.2f" % (name, self.two_fofc_values[i_seq]) reject = True break if (self.sc_fofc_mean is not None) : if (self.sc_fofc_mean < params.omit_fofc_min_sc_mean) : reject = True elif ((self.sc_two_fofc_mean < params.omit_two_fofc_min_sc_mean) and (self.sc_fofc_mean < params.omit_fofc_min_sc_mean + 1)) : reject = True flag = "" if (reject) : flag = " !!!" print >> log, prefix+\ "occupancy=%.2f rotamer=%s 2Fo-Fc(sc)=%s Fo-Fc(sc)=%s%s" % \ (self.occupancy, self.rotamer, format_value("%5f", self.sc_two_fofc_mean), format_value("%5f", self.sc_fofc_mean), flag) if (bad_mc_two_fofc_msg is not None) : print >> log, prefix+" %s" % bad_mc_two_fofc_msg return (not reject)
def format_info_string(self): return "%7s %6s %6s %6s %9s"%( self.id_str, format_value("%6.3f",self.map_cc_all), format_value("%6.3f",self.map_cc_backbone), format_value("%6.3f",self.map_cc_sidechain), self.rotamer_status)
def _show_impl (self, out) : label_suffix = "" if (self.info is not None) : label_suffix = " of %s" % str(self.info) out.show_sub_header("Maximum likelihood isotropic Wilson scaling") out.show(""" ML estimate of overall B value%s:""" % label_suffix) out.show_preformatted_text(" %s A**(-2)" % format_value("%5.2f", self.b_wilson)) out.show(""" Estimated -log of scale factor%s:""" % label_suffix) out.show_preformatted_text(""" %s""" % format_value("%5.2f", self.p_scale)) out.show("""\ The overall B value ("Wilson B-factor", derived from the Wilson plot) gives an isotropic approximation for the falloff of intensity as a function of resolution. Note that this approximation may be misleading for anisotropic data (where the crystal is poorly ordered along an axis). The Wilson B is strongly correlated with refined atomic B-factors but these may differ by a significant amount, especially if anisotropy is present.""") if (self.b_wilson < 0) : out.warn("The Wilson B-factor is negative! This indicates that "+ "the data are either unusually pathological, or have been "+ "artifically manipulated (for instance by applying anisotropic "+ "scaling directly). Please inspect the raw data and/or use "+ "unmodified reflections for phasing and refinement, as any model "+ "generated from the current dataset will be unrealistic.")
def format_for_model_cc (self) : return "%6.2f %6.2f %6d %6.2f %6.2f %5.3f %5.3f %s %s %s %s"%( self.d_max, self.d_min, self.n_uniq, self.completeness*100, self.i_over_sigma_mean, self.cc_one_half, self.cc_star, format_value("%5.3f", self.cc_work), format_value("%5.3f", self.cc_free), format_value("%5.3f", self.r_work), format_value("%5.3f", self.r_free))
def show_rfactors_targets_scales_overall(self, header = None, out=None): from cctbx import sgtbx if(out is None): out = sys.stdout out.flush() p = " " self._header_resolutions_nreflections(header=header, out=out) print >> out, "| "+" "*38+"|" self._rfactors_and_bulk_solvent_and_scale_params(out=out) line7="| normalized target function (%s) (work): %s"% ( self.target_name, n_as_s("%15.6f",self.target_work)) np = 79 - (len(line7) + 1) line7 = line7 + " "*np + "|" print >> out, line7 # no norm - work line71="| target function (%s) not normalized (work): %s"% ( self.target_name, n_as_s("%15.6f",self.target_work_no_norm)) np = 79 - (len(line71) + 1) line71 = line71 + " "*np + "|" print >> out, line71 # no norm - free line71="| target function (%s) not normalized (free): %s"% ( self.target_name, n_as_s("%15.6f",self.target_free_no_norm)) np = 79 - (len(line71) + 1) line71 = line71 + " "*np + "|" print >> out, line71 # if(self.twin_fraction is not None): line8="| twin fraction: "+format_value("%-4.2f",self.twin_fraction)+\ " twin operator: "+\ format_value("%-s",sgtbx.change_of_basis_op(self.twin_law).as_hkl()) np = 79 - (len(line8) + 1) line8 = line8 + " "*np + "|" print >> out, line8 print >> out, "|"+"-"*77+"|" out.flush()
def collect(self, iter = None, nfun = None): if(iter is not None): self.iter = format_value("%-4d", iter) if(nfun is not None): self.nfun = format_value("%-4d", nfun) self.fmodels.fmodel_xray().xray_structure == self.model.xray_structure fmodels_tg = self.fmodels.target_and_gradients( weights = self.weights, compute_gradients = False) self.rxw.append(format_value("%6.4f", self.fmodels.fmodel_xray().r_work())) self.rxf.append(format_value("%6.4f", self.fmodels.fmodel_xray().r_free())) self.ex.append(format_value("%10.4f", fmodels_tg.target_work_xray)) if(self.fmodels.fmodel_neutron() is not None): self.rnw.append(format_value("%6.4f", self.fmodels.fmodel_neutron().r_work())) self.rnf.append(format_value("%6.4f", self.fmodels.fmodel_neutron().r_free())) self.en.append(format_value("%10.4f", fmodels_tg.target_work_neutron)) if(self.refine_xyz and self.weights.w > 0): er = self.model.restraints_manager_energies_sites( compute_gradients = False).target elif(self.refine_adp and self.weights.w > 0): use_hd = False if(self.fmodels.fmodel_n is not None): use_hd = True er = self.model.energies_adp( iso_restraints = self.iso_restraints, use_hd = use_hd, compute_gradients = False).target elif(self.refine_occ): er = 0 else: er = 0 self.er.append(format_value("%10.4f", er)) self.et.append(format_value( "%10.4f", fmodels_tg.target()+er*self.weights.w))
def fs (value) : if (isinstance(value, int)) : return format_value("%d", value, replace_none_with="---") elif (isinstance(value, float)) : return format_value("%.2f", value, replace_none_with="---") else : return "---"
def show_helper(self, fmodel, log): r_work = format_value("%6.4f", fmodel.r_work()) r_free = format_value("%6.4f", fmodel.r_free()) target = format_value("%-13.3f", fmodel.target_w()) target_name = format_value("%s", fmodel.target_name) p1 = "| r_work = %s r_free = %s" % (r_work, r_free) p2 = "target_work(%s) = %s |" % (target_name, target) print >> log, p1+" "*(79-len(p1+p2))+p2
def xray_line(self, i_seq): line = "| %s = %s * %s * %s + %s * %s"%( self.et[i_seq].strip(), format_value("%6.2f",self.weights.wx).strip(), format_value("%6.2f",self.weights.wx_scale).strip(), self.ex[i_seq].strip(), format_value("%6.2f",self.weights.w).strip(), self.er[i_seq].strip()) line = line + " "*(78 - len(line))+"|" return line
def format_for_cc_star_gui (self) : return [ "%.2f - %.2f" % (self.d_max, self.d_min), str(self.n_uniq), "%.1f %%" % (self.completeness * 100), "%.1f" % self.i_over_sigma_mean, "%.3f" % self.cc_one_half, "%.3f" % self.cc_star, format_value("%5.3f", self.cc_work), format_value("%5.3f", self.cc_free), format_value("%5.3f", self.r_work), format_value("%5.3f", self.r_free) ]
def update_reflection_info (self, hkl, d_min, value) : print hkl, value if (hkl is None) : self.hkl_info.SetValue("") self.d_min_info.SetValue("") self.value_info.SetValue("") else : self.hkl_info.SetValue("%d, %d, %d" % hkl) d_min_str = format_value("%.3g", d_min) self.d_min_info.SetValue(d_min_str) value_str = format_value("%.3g", value, replace_none_with="---") self.value_info.SetValue(value_str)
def _rfactors_and_bulk_solvent_and_scale_params(self, out): out.flush() r_work = format_value("%6.4f",self.r_work).strip() r_free = format_value("%6.4f",self.r_free).strip() scale = format_value("%6.3f",self.overall_scale_k1).strip() err = format_value("%-4.2f",self.ml_coordinate_error) errl =" coordinate error (max.-lik. estimate): %s A"%err line = "| r_work= "+r_work+" r_free= "+r_free+errl np = 79 - (len(line) + 1) if(np < 0): np = 0 print >> out, line + " "*np + "|" print >> out, "| "+" "*38+"|" out.flush()
def show_targets(self, out = None, text = ""): if(out is None): out = sys.stdout part1 = "|-"+text part2 = "-|" n = 79 - len(part1+part2) print >> out, part1 + "-"*n + part2 part3 = "| target_work(%s) = %s r_work = %s r_free = %s" % ( self.target_name, format_value(format="%.6g", value = self.target_work), format_value(format="%6.4f", value = self.r_work), format_value(format="%6.4f", value = self.r_free)) n = 78 - len(str(part3)+"|") print >> out, part3, " "*n +"|" print >> out, "|" +"-"*77+"|" out.flush()
def format (self) : return "%6.2f %6.2f %6d %6d %5.2f %6.2f %8.1f %6.1f %s %s %s %5.3f %5.3f" % ( self.d_max, self.d_min, self.n_obs, self.n_uniq, self.mean_redundancy, self.completeness*100, self.i_mean, self.i_over_sigma_mean, format_value("%5.3f", self.r_merge), format_value("%5.3f", self.r_meas), format_value("%5.3f", self.r_pim), self.cc_one_half, self.anom_half_corr)
def show_summary (self, out=None) : if (out is None) : out = sys.stdout chi_angles = None if (self.chis is not None) : chi_angles = ",".join([ "%.1f" % x for x in self.chis ]) density_str = "" if (self.mean_fofc is not None) : density_str = "%6.2f %6.2f " % (self.mean_2fofc, self.mean_fofc) translation_str = "" if (self.translation is not None) : translation_str = "%4.2f,%4.2f,%4.2f " % tuple(self.translation) print >> out, """%12s %6s %6s %6s %6.3f %s%s%s""" % ( self.residue.id_str(), format_value("%6.1f", self.backrub), format_value("%6.1f", self.shear), self.rotamer, self.rmsd, translation_str, density_str, chi_angles)
def _header_resolutions_nreflections(self, header, out): if(header is None): header = "" percent="%" frac_free = self.number_of_test_reflections/self.number_of_reflections*100 line1 = "(resolution: " line2 = format_value("%6.2f",self.d_min).strip() line3 = format_value("%6.2f",self.d_max).strip() line4 = " - " line5 = " A, n_refl.=" line6 = format_value("%d",self.number_of_reflections).strip() line7 = " (all), %-6.2f%s free"%(frac_free, percent) tl = header+"-"+line1+line2+line4+line3+line5+line6+line7+")" line_len = len("|-"+"|"+tl) fill_len = 80-line_len-1 print >> out, "|-"+tl+"-"*(fill_len)+"|" out.flush()
def as_string (self, prefix="", highlight_if_heavy=False) : flag = "" if highlight_if_heavy and self.is_heavy_atom() : flag = " ***" return "%-20s %6.2f %4.2f %6.2f %6.2f %s %5.3f%s" % ( self.id_str(), self.b_iso, self.occupancy, self.two_fofc, self.fofc, format_value("%6.2f", self.anom, replace_none_with="---"), self.cc, flag)
def format_chi_angles (self, pad=False, sep=",") : formatted = [] for chi in self.chi_angles : if pad or (chi is not None) : formatted.append(format_value("%.1f", chi, replace_none_with="").strip()) return sep.join(formatted)
def format_molprobity_scores(self, prefix=""): clashscore_explanation = '"Clashscore and/or Probe failed to process model"' result="%s" % prefix if(self.ramachandran_outliers is not None): result = """%sMOLPROBITY STATISTICS. %s ALL-ATOM CLASHSCORE : %s %s RAMACHANDRAN PLOT: %s OUTLIERS : %-5.2f %s %s ALLOWED : %-5.2f %s %s FAVORED : %-5.2f %s %s ROTAMER OUTLIERS : %s %s %s CBETA DEVIATIONS : %-d %s PEPTIDE PLANE: %s CIS-PROLINE : %s %s CIS-GENERAL : %s %s TWISTED PROLINE : %s %s TWISTED GENERAL : %s"""%( prefix, prefix, format_value("%-6.2f", self.clashscore, replace_none_with=clashscore_explanation).strip(), prefix, prefix, self.ramachandran_outliers, "%", prefix, self.ramachandran_allowed, "%", prefix, self.ramachandran_favored, "%", prefix, str("%6.2f"%(self.rotamer_outliers)).strip(),"%", prefix, self.c_beta_dev, prefix, prefix, str(self.n_cis_proline), prefix, str(self.n_cis_general), prefix, str(self.n_twisted_proline), prefix, str(self.n_twisted_general)) if not prefix: result = self._capitalize(result) return result
def show(self, fmodels, message, log): if(log is not None): print >> log, "|-"+message+"-"*(79-len("|-"+message+"|"))+"|" fm_x, fm_n = fmodels.fmodel_xray(), fmodels.fmodel_neutron() if(fm_n is not None): print >> log, "|"+" "*36+"X-ray"+" "*36+"|" self.show_helper(fmodel = fm_x, log = log) if(fm_n is not None): print >> log, "|"+" "*35+"neutron"+" "*35+"|" self.show_helper(fmodel = fm_n, log = log) occupancies = fm_x.xray_structure.scatterers().extract_occupancies() occ_max = format_value("%4.2f", flex.max(occupancies)) occ_min = format_value("%4.2f", flex.min(occupancies)) number_small = format_value("%8d", (occupancies < 0.1).count(True)) print >> log, \ "| occupancies: max = %s min = %s number of occupancies < 0.1: %s |"%( occ_max, occ_min, number_small) print >> log, "|"+"-"*77+"|"
def show_rfactors_targets_in_bins(self, out = None): if(out is None): out = sys.stdout print >> out, "|"+"-"*77+"|" print >> out, "| Bin Resolution Compl. No. Refl. R-factors Targets |" print >> out, "|number range work test work test work test|" for bin in self.bins: print >> out, "|%3d: %-17s %4.2f %6d %4d %s %s %s %s|" % ( bin.i_bin, bin.d_range, bin.completeness, bin.n_work, bin.n_free, format_value("%6.4f", bin.r_work), format_value("%6.4f", bin.r_free), format_value("%11.5g", bin.target_work), format_value("%11.5g", bin.target_free)) print >> out, "|"+"-"*77+"|" out.flush()
def GetItemText (self, item, col) : n_items = self.GetItemCount() solution = self.table[item] if (col == 0) : return solution['counter'] elif (col == 1) : return "%s%s" % (str_utils.format_value("%.4f", solution['max_angular_difference']), chr(161)) elif (col == 2) : return str_utils.format_value("%.4f", solution['residual']) elif (col == 3) : return str(solution['count_GOOD']) elif (col == 4) : return "%s %s" % (solution['system'], solution['bravais']) elif (col == 5) : unit_cell = solution['orient'].unit_cell() return "%g %g %g %g %g %g" % unit_cell.parameters() elif (col == 6) : unit_cell = solution['orient'].unit_cell() return str(int(unit_cell.volume()))
def show(self, prefix="", log=None): self.assert_pdb_hierarchy_xray_structure_sync() if(log is None): log = sys.stdout fmt = """%s Map CC (whole unit cell): %-6.3f %s Map CC (around atoms): %-6.3f %s rmsd (bonds): %-s %s rmsd (angles): %-s %s Dist. moved from start: %-6.3f %s Dist. moved from previous: %-6.3f %s All-atom clashscore %-s %s Ramachandran plot: %s outliers: %-s %% %s allowed: %-s %% %s favored: %-s %% %s Rotamer outliers: %-s %% %s C-beta deviations: %-s """ if(self.geometry_restraints_manager is not None): mso = model_statistics.geometry( pdb_hierarchy = self.pdb_hierarchy, molprobity_scores = libtbx.env.has_module("probe"), restraints_manager = self.geometry_restraints_manager) print >> log, fmt%( prefix, self.map_cc_whole_unit_cell, prefix, self.map_cc_around_atoms, prefix, format_value("%-6.2f", self.rmsd_b).strip(), prefix, format_value("%-6.2f", self.rmsd_a).strip(), prefix, self.dist_from_start, prefix, self.dist_from_previous, prefix, format_value("%-6.2f", mso.clashscore), prefix, prefix, format_value("%-5.2f", mso.ramachandran_outliers), prefix, format_value("%-5.2f", mso.ramachandran_allowed), prefix, format_value("%-5.2f", mso.ramachandran_favored), prefix, format_value("%6.2f", mso.rotamer_outliers).strip(), prefix, format_value("%-3d", mso.c_beta_dev)) else: print >> log, fmt%( prefix, self.map_cc_whole_unit_cell, prefix, self.map_cc_around_atoms, prefix, "None", prefix, "None", prefix, self.dist_from_start, prefix, self.dist_from_previous, prefix, "None", prefix, prefix, "None", prefix, "None", prefix, "None", prefix, "None", prefix, "None")
def formatted_string(self): result = "%s %s %s %s %s %s %s" % ( format_value("%6s",self.file_name), format_value("%6s",str(self.r_work)), format_value("%6s",str(self.r_free)), format_value("%6s",str(self.sigma)), format_value("%6s",str(self.high)), format_value("%6s",str(self.low)), format_value("%6s",str(self.resolution))) return result
def show_rwork_rfree_number_completeness(self, prefix="", title=None, out = None): if(out is None): out = sys.stdout if(title is not None): print >> out, prefix+title print >> out,\ prefix+" BIN RESOLUTION RANGE COMPL. NWORK NFREE RWORK RFREE CCWORK CCFREE" fmt = " %s %s %s %s %s %s %s %s %s" for bin in self.bins: print >> out,prefix+fmt%( format_value("%3d", bin.i_bin), format_value("%-17s", bin.d_range), format_value("%4.2f", bin.completeness), format_value("%8d", bin.n_work), format_value("%5d", bin.n_free), format_value("%6.4f", bin.r_work), format_value("%6.4f", bin.r_free), format_value("%5.3f", bin.cc_work), format_value("%5.3f", bin.cc_free))
def show_observations(obs,out=None, n_bins=12): if out==None: import sys out = sys.stdout from libtbx.str_utils import format_value obs.setup_binner(n_bins = n_bins) result = [] counts_given = obs.binner().counts_given() counts_complete = obs.binner().counts_complete() for i_bin in obs.binner().range_used(): sel_w = obs.binner().selection(i_bin) sel_fo_all = obs.select(sel_w) d_max_,d_min_ = sel_fo_all.d_max_min() d_range = obs.binner().bin_legend( i_bin=i_bin, show_bin_number=False, show_counts=True) sel_data = obs.select(sel_w).data() sel_sig = obs.select(sel_w).sigmas() if(sel_data.size() > 0): bin = resolution_bin( i_bin = i_bin, d_range = d_range, mean_I = flex.mean(sel_data), n_work = sel_data.size(), mean_I_sigI = flex.mean(sel_data/sel_sig), d_max_min = (d_max_, d_min_), completeness = (counts_given[i_bin], counts_complete[i_bin])) result.append(bin) print >>out, "\n Bin Resolution Range Compl. <I> <I/sig(I)>" for bin in result: fmt = " %s %s %s %s" print >>out,fmt%( format_value("%3d", bin.i_bin), format_value("%-17s", bin.d_range), format_value("%8.1f", bin.mean_I), format_value("%8.1f", bin.mean_I_sigI), ) return result
def show_current_r_factors_summary (self, out, prefix="") : if (len(self.steps) == 0) : return last_step = self.steps[-1].replace(":", "") fields = last_step.split("_") action_label = None if (len(fields) >= 2) : cycle = fields[0] action = "_".join(fields[1:]) action_label = show_actions.get(action, None) if (action_label is None) : return action_label = cycle + "_" + action_label if (action_label is None) : if (len(self.steps) == 1) : action_label = "start" else : action_label = "end" print >> out, "%s%-6s r_work=%s r_free=%s" % (prefix, action_label, format_value("%.4f", self.r_works[-1]), format_value("%.4f", self.r_frees[-1]))
def finish_job (result) : stats = [] if (result is not None) : stats = [ ("High resolution", format_value("%.3g", result.overall.d_min)), ("Redundancy", format_value("%.1f", result.overall.mean_redundancy)), ("R-meas", format_value("%.3g", result.overall.r_meas)), ("R-meas (high-res)", format_value("%.3g", result.bins[-1].r_meas)), ("<I/sigma>", format_value("%.2g", result.overall.i_over_sigma_mean)), ("<I/sigma> (high-res)", format_value("%.2g", result.bins[-1].i_over_sigma_mean)), ("Completeness", format_value("%.1f%%", result.overall.completeness*100)), ("Completeness (high-res)", format_value("%.1f%%", result.bins[-1].completeness*100)), ] return ([], stats)
def get_statistics_for_phenix_gui (self) : mp = self stats = [ ("R-work", format_value("%.4f", mp.r_work())), ("R-free", format_value("%.4f", mp.r_free())), ("RMS(bonds)", format_value("%.3f", mp.rms_bonds())), ("RMS(angles)", format_value("%.4f", mp.rms_angles())), ("Clashscore", format_value("%.2f", mp.clashscore())), ("MolProbity score", format_value("%.3f", mp.molprobity_score())), ] if (self.neutron_stats is not None) : stats.extend([ ("R-work (neutron)", format_value("%.4f", self.neutron_stats.r_work)), ("R-free (neutron)", format_value("%.4f", self.neutron_stats.r_free)), ]) return stats
def run(args, log=sys.stdout): """phenix.map_model_cc or phenix.model_map_cc: Given PDB file and a map file calculate model-map coorelation. How to run: phenix.map_model_cc model.pdb map.ccp4 resolution=3 phenix.model_map_cc model.pdb map.ccp4 resolution=3 Feedback: [email protected] [email protected] """ assert len(locals().keys()) == 2 # intentional print >> log, "-" * 79 print >> log, run.__doc__ print >> log, "-" * 79 # Get inputs inputs = get_inputs(args=args, log=log, master_params=master_params()) # Model broadcast(m="Input PDB:", log=log) print >> log, inputs.pdb_file_name # ideally this should not be available here inputs.pdb_hierarchy.show(level_id="chain") # Crystal symmetry broadcast(m="Box (unit cell) info:", log=log) inputs.crystal_symmetry.show_summary(f=log) # Map broadcast(m="Input map:", log=log) inputs.ccp4_map_object.show_summary(prefix=" ") # Run task in 4 separate steps task_obj = mmtbx.maps.map_model_cc.map_model_cc( map_data=inputs.ccp4_map_object.data.as_double(), pdb_hierarchy=inputs.pdb_hierarchy, crystal_symmetry=inputs.crystal_symmetry, params=inputs.params.map_model_cc) task_obj.validate() task_obj.run() results = task_obj.get_results() if inputs.params.pkl_file_name is not None: easy_pickle.dump( file_name=inputs.params.pkl_file_name, obj=group_args( cc_mask=results.cc_mask, cc_volume=results.cc_volume, cc_peaks=results.cc_peaks, cc_per_chain=results.cc_per_chain, # cc_per_residue = results.cc_per_residue, # not pickleable because of residue in it and big size fsc=results.fsc, )) # broadcast(m="Map resolution:", log=log) print >> log, " Resolution:", inputs.params.map_model_cc.resolution broadcast(m="Map-model CC (overall):", log=log) print >> log, " CC_mask : %s" % format_value("%6.4f", results.cc_mask) print >> log, " CC_volume: %s" % format_value("%6.4f", results.cc_volume) print >> log, " CC_peaks : %s" % format_value("%6.4f", results.cc_peaks) if results.fsc is not None: broadcast(m="Model-map FSC:", log=log) if (inputs.params.output_file_name_prefix is None): out = log else: fsc_fn = "%s_fsc.log" % inputs.params.output_file_name_prefix out = open(fsc_fn, "w") print >> log, " saved to:", fsc_fn print >> out, " 1/resolution CC" for a, b in zip(results.fsc.d_inv, results.fsc.fsc): print >> out, "%15.9f %15.9f" % (a, b) if (inputs.params.output_file_name_prefix is not None): out.close() if len(results.cc_per_chain) + len(results.cc_per_residue) > 0: broadcast(m="Map-model CC (local):", log=log) # Per chain if len(results.cc_per_chain) > 0: print >> log, "Per chain:" print >> log, "chain ID CC <B> <occ> N atoms" fmt = "%s %7.4f %8.3f %4.2f %d" for r in results.cc_per_chain: print fmt % (r.chain_id, r.cc, r.b_iso_mean, r.occ_mean, r.n_atoms) # Per residue if len(results.cc_per_residue) > 0: print >> log, "Per residue:" fmt = "%s %s %s %7.4f %8.3f %4.2f" for r in results.cc_per_residue: print fmt % (r.chain_id, r.resname, r.resseq, r.cc, r.b_iso_mean, r.occ_mean) return None
def format_score(self, replace_none_with="None"): return format_value(self.score_format, self.score, replace_none_with=replace_none_with)
def fv (fs, val) : return format_value(fs, val, replace_none_with="----")
def show(self, log=None): if (log is None): log = sys.stdout # crystal print >> log, " Unit cell: ", self.crystal.uc print >> log, " Space group: ", self.crystal.sg, \ "number of symmetry operations:", self.crystal.n_sym_op # models print >> log, " Number of models:", len(self.models) for i_seq, i_model in enumerate(self.models): print >> log, " Model #%s:" % str("%d" % (i_seq + 1)).strip() print >> log, " Number of residues in alternative conformations:", \ i_model.n_residues_in_altlocs print >> log, " Residue content:" len_max = 0 for k in i_model.resname_classes: k = k.split() if (len(k[0]) > len_max): len_max = len(k[0]) fmt = " %-" + str(len_max) + "s : %s" for rc in i_model.resname_classes: k, v = rc.split() print >> log, fmt % (k, v) x = i_model.xray_structure_stat print >> log, " Atoms:" print >> log, " content: %s" % x.all.n_atoms max_field_for_element_count = 1 for element_occupancy_sum in x.all.atom_counts_str.split(): individual_element_count_len = len( element_occupancy_sum.split(":")[1]) if (individual_element_count_len > max_field_for_element_count): max_field_for_element_count = individual_element_count_len for element_occupancy_sum in x.all.atom_counts_str.split(): iecl = "%" + str(max_field_for_element_count) + "s" fmt = " %s " + "count: %s " % iecl + "occupancy sum: %s" print >> log, fmt % tuple(element_occupancy_sum.split(":")) print >> log, " ADP (min,max,mean):" print >> log, " all (%s atoms): %s %s %s" % ( x.all.n_atoms, x.all.b_min, x.all.b_max, x.all.b_mean) if (x.sidechain is not None): print >> log, " side chains (%s atoms): %s %s %s" % ( x.sidechain.n_atoms, x.sidechain.b_min, x.sidechain.b_max, x.sidechain.b_mean) if (x.backbone is not None): print >> log, " main chains (%s atoms): %s %s %s" % ( x.backbone.n_atoms, x.backbone.b_min, x.backbone.b_max, x.backbone.b_mean) if (x.macromolecule is not None): print >> log, " macromolecule (%s atoms): %s %s %s" % ( x.macromolecule.n_atoms, x.macromolecule.b_min, x.macromolecule.b_max, x.macromolecule.b_mean) if (x.ligand is not None): print >> log, " ligands (%s atoms): %s %s %s" % ( x.ligand.n_atoms, x.ligand.b_min, x.ligand.b_max, x.ligand.b_mean) if (x.solvent is not None): print >> log, " solvent (%s atoms): %s %s %s" % ( x.solvent.n_atoms, x.solvent.b_min, x.solvent.b_max, x.solvent.b_mean) if (i_model.rms_b_iso_or_b_equiv_bonded is not None): print >> log, " mean bonded (Bi-Bj) : %s" % format_value( "%8.2f", i_model.rms_b_iso_or_b_equiv_bonded).strip() print >> log, " occupancies (min,max,mean) : %s %s %s" % ( x.all.o_min, x.all.o_max, x.all.o_mean) print >> log, " number_of_anisotropic : " + format_value( "%-7s", x.all.n_aniso) print >> log, " number_of_non_positive_definite : %s" % x.all.n_npd g = i_model.geometry_all if (g is not None): print >> log, " Stereochemistry statistics (mean, max, count) - overall:" print >> log, " bonds : %8.4f %8.4f %d" % ( g.b[2], g.b[1], g.b_number) print >> log, " angles : %8.4f %8.4f %d" % ( g.a[2], g.a[1], g.a_number) print >> log, " dihedrals : %8.4f %8.4f %d" % ( g.d[2], g.d[1], g.d_number) print >> log, " chirality : %8.4f %8.4f %d" % ( g.c[2], g.c[1], g.c_number) print >> log, " planarity : %8.4f %8.4f %d" % ( g.p[2], g.p[1], g.p_number) print >> log, " non-bonded (min) : %8.4f" % (g.n[0]) if ([i_model.geometry_solvent, i_model.geometry_ligand].count(None) == 0): g = i_model.geometry_macromolecule if (g is not None): print >> log, " Stereochemistry statistics (mean, max, count) - macromolecule:" print >> log, " bonds : %8.4f %8.4f %d" % ( g.b[2], g.b[1], g.b_number) print >> log, " angles : %8.4f %8.4f %d" % ( g.a[2], g.a[1], g.a_number) print >> log, " dihedrals : %8.4f %8.4f %d" % ( g.d[2], g.d[1], g.d_number) print >> log, " chirality : %8.4f %8.4f %d" % ( g.c[2], g.c[1], g.c_number) print >> log, " planarity : %8.4f %8.4f %d" % ( g.p[2], g.p[1], g.p_number) print >> log, " non-bonded (min) : %8.4f" % (g.n[0]) g = i_model.geometry_ligand if (g is not None): print >> log, " Stereochemistry statistics (mean, max, count) - ligands:" print >> log, " bonds : %8.4f %8.4f %d" % ( g.b[2], g.b[1], g.b_number) print >> log, " angles : %8.4f %8.4f %d" % ( g.a[2], g.a[1], g.a_number) print >> log, " dihedrals : %8.4f %8.4f %d" % ( g.d[2], g.d[1], g.d_number) print >> log, " chirality : %8.4f %8.4f %d" % ( g.c[2], g.c[1], g.c_number) print >> log, " planarity : %8.4f %8.4f %d" % ( g.p[2], g.p[1], g.p_number) print >> log, " non-bonded (min) : %8.4f" % (g.n[0]) g = i_model.geometry_solvent if (g is not None): print >> log, " Stereochemistry statistics - solvent:" print >> log, " non-bonded (min) : %8.4f" % (g.n[0]) if (i_model.molprobity is not None): outl = i_model.molprobity.ramalyze_outliers allo = i_model.molprobity.ramalyze_allowed favo = i_model.molprobity.ramalyze_favored print >> log, " Molprobity statistics:" print >> log, " Ramachandran plot, number of:" print >> log, " outliers : %-5d (%-5.2f %s)" % ( outl[0], outl[1] * 100., "%") print >> log, " allowed : %-5d (%-5.2f %s)" % ( allo[0], allo[1] * 100., "%") print >> log, " favored : %-5d (%-5.2f %s)" % ( favo[0], favo[1] * 100., "%") print >> log, " Rotamer outliers : %d (%s %s)" % ( i_model.molprobity.rotalyze[0], str("%6.2f" % (i_model.molprobity.rotalyze[1] * 100.)).strip(), "%") print >> log, " Cbeta deviations >0.25A : %d" % i_model.molprobity.cbetadev print >> log, " All-atom clashscore : %.2f (steric overlaps >0.4A per 1000 atoms)"% \ i_model.molprobity.clashscore print >> log, " Overall score : %.2f" % \ i_model.molprobity.mpscore # print >> log, " Data:" result = " \n ".join([ "data_label : %s" % self.data.data_label, "high_resolution : " + format_value("%-5.2f", self.data.high_resolution), "low_resolution : " + format_value("%-6.2f", self.data.low_resolution), "completeness_in_range : " + format_value("%-6.2f", self.data.completeness_in_range), "completeness(d_min-inf) : " + format_value("%-6.2f", self.data.completeness_d_min_inf), "completeness(6A-inf) : " + format_value("%-6.2f", self.data.completeness_6A_inf), "wilson_b : " + format_value("%-6.1f", self.data.wilson_b), "number_of_reflections : " + format_value("%-8d", self.data.number_of_reflections), "number_of_reflections(non-anomalous) : " + format_value("%-8d", self.data.number_of_reflections_merged), "test_set_size : " + format_value("%-8.4f", self.data.test_set_size), "test_flag_value : " + format_value("%-s", self.data.test_flag_value), "number_of_Fobs_outliers : " + format_value("%-8d", self.data.number_of_Fobs_outliers), "twinned : " + format_value("%-s", self.data.twinned), "anomalous_flag : " + format_value("%-6s", self.data.anomalous_flag) ]) print >> log, " ", result # print >> log, " Model_vs_Data:" result = [ "r_work(re-computed) : %s" % format_value("%-6.4f", self.model_vs_data.r_work).strip(), "r_free(re-computed) : %s" % format_value("%-6.4f", self.model_vs_data.r_free).strip(), "mean phase error estimate (deg) : %s" % format_value( "%-7.2f", self.model_vs_data.mean_phase_error).strip(), ] ml_err = self.model_vs_data.ml_coordinate_error if (ml_err is not None): result.append("ml coordinate error estimate (A) : %s" % format_value("%-6.2f", ml_err).strip()) sc = self.model_vs_data.solvent_content_via_mask if (sc is not None): sc *= 100 result.append("solvent_content_estimated_via_mask : %-s %%" % format_value("%.1f", sc)) result = " \n ".join(result) print >> log, " ", result # if (self.pdb_header is not None): print >> log, " Information extracted from PDB file header:" print >> log, " program_name : %-s" % format_value( "%s", self.pdb_header.program_name) print >> log, " year : %-s" % format_value( "%s", self.pdb_header.year) print >> log, " r_work : %-s" % format_value( "%s", self.pdb_header.r_work) print >> log, " r_free : %-s" % format_value( "%s", self.pdb_header.r_free) print >> log, " high_resolution : %-s" % format_value( "%s", self.pdb_header.high_resolution) print >> log, " low_resolution : %-s" % format_value( "%s", self.pdb_header.low_resolution) print >> log, " sigma_cutoff : %-s" % format_value( "%s", self.pdb_header.sigma_cutoff) print >> log, " matthews_coeff : %-s" % format_value( "%s", self.pdb_header.matthews_coeff) if (self.pdb_header.solvent_cont is not None): print >> log, " solvent_cont : %-s %%" % format_value( "%s", self.pdb_header.solvent_cont) else: print >> log, " solvent_cont : %-s" % format_value( "%s", self.pdb_header.solvent_cont) if (self.pdb_header.tls is not None): print >> log, " TLS : %-s" % format_value( "%s", " ".join([ str(self.pdb_header.tls.pdb_inp_tls.tls_present), "(number of groups: %s)" % str(len(self.pdb_header.tls.tls_selections)) ])) else: print >> log, " TLS : None" if (self.pdb_header.exptl_method is not None): print >> log, " exptl_method : %-s" % format_value( "%s", self.pdb_header.exptl_method) # print >> log, " After applying resolution and sigma cutoffs:" print >> log, " n_refl_cutoff : %-s" % format_value( "%d", self.misc.n_refl_cutoff).strip() print >> log, " r_work_cutoff : %-s" % format_value( "%6.4f", self.misc.r_work_cutoff).strip() print >> log, " r_free_cutoff : %-s" % format_value( "%6.4f", self.misc.r_free_cutoff).strip()
def format_info_string(self): return "%7s %6s %6s %6s %9s" % ( self.id_str, format_value("%6.3f", self.map_cc_all), format_value("%6.3f", self.map_cc_backbone), format_value("%6.3f", self.map_cc_sidechain), self.rotamer_status)
def show_remark_3(self, out = None): from cctbx import sgtbx if(out is None): out = sys.stdout pr = "REMARK 3 " print(pr+"REFINEMENT TARGET : %s"%self.target_name.upper(), file=out) print(pr, file=out) print(pr+"DATA USED IN REFINEMENT.", file=out) print(pr+" RESOLUTION RANGE HIGH (ANGSTROMS) : %s"%format_value("%-8.2f", self.d_min), file=out) print(pr+" RESOLUTION RANGE LOW (ANGSTROMS) : %s"%format_value("%-8.2f", self.d_max), file=out) print(pr+" MIN(FOBS/SIGMA_FOBS) : %s"%format_value("%-6.2f", self.min_f_obs_over_sigma), file=out) print(pr+" COMPLETENESS FOR RANGE (%s) : %-6.2f"%\ ("%", self.completeness_in_range*100.0), file=out) print(pr+" NUMBER OF REFLECTIONS : %-10d"%self.number_of_reflections, file=out) print(pr+" NUMBER OF REFLECTIONS (NON-ANOMALOUS) : %-10d"%self.number_of_reflections_merged, file=out) print(pr, file=out) print(pr+"FIT TO DATA USED IN REFINEMENT.", file=out) print(pr+" R VALUE (WORKING + TEST SET) : %s"%format_value("%-6.4f",self.r_all), file=out) print(pr+" R VALUE (WORKING SET) : %s"%format_value("%-6.4f", self.r_work), file=out) print(pr+" FREE R VALUE : %s"%format_value("%-6.4f", self.r_free), file=out) print(pr+" FREE R VALUE TEST SET SIZE (%s) : %-6.2f"%("%", float(self.number_of_test_reflections)/self.number_of_reflections*100.), file=out) print(pr+" FREE R VALUE TEST SET COUNT : %-10d"%self.number_of_test_reflections, file=out) print(pr, file=out) self.show_rwork_rfree_number_completeness(prefix = pr, title = "FIT TO DATA USED IN REFINEMENT (IN BINS).", out = out) print(pr, file=out) print(pr+"BULK SOLVENT MODELLING.", file=out) print(pr+" METHOD USED : FLAT BULK SOLVENT MODEL", file=out) print(pr+" SOLVENT RADIUS : %s"%format_value("%-8.2f", self.mask_solvent_radius), file=out) print(pr+" SHRINKAGE RADIUS : %s"%format_value("%-8.2f", self.mask_shrink_radius), file=out) print(pr+" GRID STEP FACTOR : %s"%format_value("%-8.2f", self.mask_grid_step_factor), file=out) print(pr, file=out) if(self.twin_fraction is not None): print(pr+"TWINNING INFORMATION.", file=out) print(pr+" FRACTION: %s"%format_value("%-8.3f", self.twin_fraction), file=out) print(pr+" OPERATOR: %s"%\ format_value("%-s", sgtbx.change_of_basis_op(self.twin_law).as_hkl()), file=out) print(pr+"ERROR ESTIMATES.", file=out) print(pr+" COORDINATE ERROR (MAXIMUM-LIKELIHOOD BASED) : %s"%\ format_value("%-8.2f", self.ml_coordinate_error), file=out) print(pr+" PHASE ERROR (DEGREES, MAXIMUM-LIKELIHOOD BASED) : %s"%\ format_value("%-8.2f", self.ml_phase_error), file=out) print(pr, file=out) print(pr+"STRUCTURE FACTORS CALCULATION ALGORITHM : %-s"%\ self.sf_algorithm.upper(), file=out) print(pr+"B VALUES.", file=out) print(pr+" FROM WILSON PLOT (A**2) : %s" %\ format_value("%-8.2f", self.wilson_b), file=out) out.flush()
def as_remark_200(self, wavelength=None): from libtbx.test_utils import approx_equal synchrotron = wl = "NULL" if (wavelength is not None): out = StringIO() # XXX somewhat risky... if (not approx_equal(wavelength, 1.5418, eps=0.01, out=out) and not approx_equal(wavelength, 0.7107, eps=0.01, out=out)): synchrotron = "Y" else: synchrotron = "N" wl = "%.4f" % wavelength lines = [] lines.append("") lines.append("EXPERIMENTAL DETAILS") lines.append(" EXPERIMENT TYPE : X-RAY DIFFRACTION") lines.append(" DATE OF DATA COLLECTION : NULL") lines.append(" TEMPERATURE (KELVIN) : NULL") lines.append(" PH : NULL") lines.append(" NUMBER OF CRYSTALS USED : NULL") lines.append("") lines.append(" SYNCHROTRON (Y/N) : NULL") lines.append(" RADIATION SOURCE : NULL") lines.append(" BEAMLINE : NULL") lines.append(" X-RAY GENERATOR MODEL : NULL") lines.append(" MONOCHROMATIC OR LAUE (M/L) : M") lines.append(" WAVELENGTH OR RANGE (A) : %s" % wl) lines.append(" MONOCHROMATOR : NULL") lines.append(" OPTICS : NULL") lines.append("") lines.append(" DETECTOR TYPE : NULL") lines.append(" DETECTOR MANUFACTURER : NULL") lines.append(" INTENSITY-INTEGRATION SOFTWARE : NULL") lines.append(" DATA SCALING SOFTWARE : NULL") lines.append("") lines.append("OVERALL.") comp_overall = format_value("%.1f", self.overall.completeness * 100) mult_overall = format_value("%.1f", self.overall.mean_redundancy) rmerg_overall = format_value("%.5f", self.overall.r_merge) s2n_overall = format_value("%.4f", self.overall.i_over_sigma_mean) lines.append(" COMPLETENESS FOR RANGE (%%) : %s" % comp_overall) lines.append(" DATA REDUNDANCY : %s" % mult_overall) lines.append(" R MERGE (I) : %s" % rmerg_overall) lines.append(" R SYM (I) : NULL") lines.append(" <I/SIGMA(I)> FOR THE DATA SET : %s" % s2n_overall) lines.append("") lines.append("IN THE HIGHEST RESOLUTION SHELL.") bin_stats = self.bins[-1] d_max = format_value("%.2f", bin_stats.d_max) d_min = format_value("%.2f", bin_stats.d_min) comp_lastbin = format_value("%.1f", bin_stats.completeness * 100) mult_lastbin = format_value("%.1f", bin_stats.mean_redundancy) rmerg_lastbin = format_value("%.5f", bin_stats.r_merge) s2n_lastbin = format_value("%.4f", bin_stats.i_over_sigma_mean) lines.append(" HIGHEST RESOLUTION SHELL, RANGE HIGH (A) : %s" % d_min) lines.append(" HIGHEST RESOLUTION SHELL, RANGE LOW (A) : %s" % d_max) lines.append(" COMPLETENESS FOR SHELL (%%) : %s" % comp_lastbin) lines.append(" DATA REDUNDANCY IN SHELL : %s" % mult_lastbin) lines.append(" R MERGE FOR SHELL (I) : %s" % rmerg_lastbin) lines.append(" R SYM FOR SHELL (I) : NULL") lines.append(" <I/SIGMA(I)> FOR SHELL : %s" % s2n_lastbin) lines.append("") remark_lines = ["REMARK 200 %s" % line for line in lines] return "\n".join(remark_lines)
def fs(format, value): return str_utils.format_value(format, value, replace_none_with=("(none)"))
def format(self): return "resolution = %s intensity = %.2f slow=%d fast=%d" % ( format_value("%.2f A", self.d_min), self.intensity, self.slow, self.fast)
def f(v): return format_value(format=format, value=v)
def __init__(self, obs, unobstructed, params, out=None, n_bins=12): if out == None: import sys out = sys.stdout from libtbx.str_utils import format_value self.params = params self.out = out self.obs = obs obs.setup_binner(n_bins=n_bins) attenuated = obs.select(~unobstructed) unattenuated = obs.select(unobstructed) attenuated.use_binning_of(obs) unattenuated.use_binning_of(obs) self.result = [] counts_given = obs.binner().counts_given() counts_complete = obs.binner().counts_complete() counts_given_attenuated = attenuated.binner().counts_given() counts_given_unattenuated = unattenuated.binner().counts_given() for i_bin in obs.binner().range_used(): sel_w = obs.binner().selection(i_bin) sel_fo_all = obs.select(sel_w) d_max_, d_min_ = sel_fo_all.d_max_min() d_range = obs.binner().bin_legend(i_bin=i_bin, show_bin_number=False, show_counts=True) sel_data = obs.select(sel_w).data() sel_sig = obs.select(sel_w).sigmas() sel_unatten_w = unattenuated.binner().selection(i_bin) sel_unatten_data = unattenuated.select(sel_unatten_w).data() sel_unatten_sig = unattenuated.select(sel_unatten_w).sigmas() sel_atten_w = attenuated.binner().selection(i_bin) sel_atten_data = attenuated.select(sel_atten_w).data() sel_atten_sig = attenuated.select(sel_atten_w).sigmas() if len(sel_unatten_data) > 0: unatten_mean_I = flex.mean(sel_unatten_data) unatten_mean_I_sigI = flex.mean(sel_unatten_data / sel_unatten_sig) else: unatten_mean_I = 0 unatten_mean_I_sigI = 0 if len(sel_atten_data) > 0: atten_mean_I = flex.mean(sel_atten_data) atten_mean_I_sigI = flex.mean(sel_atten_data / sel_atten_sig) else: atten_mean_I = 0 atten_mean_I_sigI = 0 if (sel_data.size() > 0): bin = resolution_bin( i_bin=i_bin, d_range=d_range, mean_I=flex.mean(sel_data), n_work=sel_data.size(), mean_I_sigI=flex.mean(sel_data / sel_sig), d_max_min=(d_max_, d_min_), completeness=(counts_given[i_bin], counts_complete[i_bin]), given_unatten=counts_given_unattenuated[i_bin], unatten_mean_I=unatten_mean_I, unatten_mean_I_sigI=unatten_mean_I_sigI, given_atten=counts_given_attenuated[i_bin], atten_mean_I=atten_mean_I, atten_mean_I_sigI=atten_mean_I_sigI, ) self.result.append(bin) self.set_limits(unobstructed) print >> out, "\n Bin Resolution Range Compl. <I> <I/sig(I)> Unobstructed <I> <I/sig(I)> Obstructed <I> <I/sig(I)>" for bin in self.result: fmt = " %s %s %s %s%s %s %s %s%s %s %s %s%s" print >> out, fmt % ( format_value("%3d", bin.i_bin), format_value("%-17s", bin.d_range), format_value("%8.1f", bin.mean_I), format_value("%8.2f", bin.mean_I_sigI), format_value("%1s", getattr(bin, "limit", " ")), format_value("%6d", bin.given_unatten), format_value("%8.1f", bin.unatten_mean_I), format_value("%8.2f", bin.unatten_mean_I_sigI), format_value("%1s", getattr(bin, "unatten_limit", " ")), format_value("%6d", bin.given_atten), format_value("%8.1f", bin.atten_mean_I), format_value("%8.2f", bin.atten_mean_I_sigI), format_value("%1s", getattr(bin, "atten_limit", " ")), )
def show_fom_pher_alpha_beta_in_bins(self, out = None): if(out is None): out = sys.stdout print("|"+"-"*77+"|", file=out) print("|R-free likelihood based estimates for figures of merit, absolute phase error,|", file=out) print("|and distribution parameters alpha and beta (Acta Cryst. (1995). A51, 880-887)|", file=out) print("|"+" "*77+"|", file=out) print("| Bin Resolution No. Refl. FOM Phase Scale Alpha Beta |", file=out) print("| # range work test error factor |", file=out) for bin in self.bins: print("|%3d: %-17s%6d%6d%s%s%s%s%s|" % ( bin.i_bin, bin.d_range, bin.n_work, bin.n_free, format_value("%6.2f", bin.fom_work), format_value("%7.2f", bin.pher_work), format_value("%7.2f", bin.scale_k1_work), format_value("%9.2f", bin.alpha_work), format_value("%14.2f", bin.beta_work)), file=out) print("|alpha: min =%s max =%s mean =%s|"%( format_value("%12.2f", self.alpha_work_min), format_value("%16.2f", self.alpha_work_max), format_value("%13.2f", self.alpha_work_mean)), file=out) print("|beta: min =%s max =%s mean =%s|"%( format_value("%12.2f", self.beta_work_min), format_value("%16.2f", self.beta_work_max), format_value("%13.2f", self.beta_work_mean)), file=out) print("|figures of merit: min =%s max =%s mean =%s|"%( format_value("%12.2f", self.fom_work_min), format_value("%16.2f", self.fom_work_max), format_value("%13.2f", self.fom_work_mean)), file=out) print("|phase err.(work): min =%s max =%s mean =%s|"%( format_value("%12.2f", self.pher_work_min), format_value("%16.2f", self.pher_work_max), format_value("%13.2f", self.pher_work_mean)), file=out) print("|phase err.(test): min =%s max =%s mean =%s|"%( format_value("%12.2f", self.pher_free_min), format_value("%16.2f", self.pher_free_max), format_value("%13.2f", self.pher_free_mean)), file=out) print("|"+"-"*77+"|", file=out) out.flush()
def n_as_s(format, value): if (value is None): return format_value(format=format, value=value) if (isinstance(value, (int, float))): return (format % value).strip() return [(format % v).strip() for v in value]
def print_table(self): from libtbx import table_utils from libtbx.str_utils import format_value table_header = [ "Tile", "Dist", "Nobs", "aRmsd", "Rmsd", "delx", "dely", "disp", "rotdeg", "Rsigma", "Tsigma" ] table_data = [] table_data.append(table_header) sort_radii = flex.sort_permutation(flex.double(self.radii)) tile_rmsds = flex.double() radial_sigmas = flex.double(len(self.tiles) // 4) tangen_sigmas = flex.double(len(self.tiles) // 4) for idx in range(len(self.tiles) // 4): x = sort_radii[idx] if self.tilecounts[x] < 3: wtaveg = 0.0 radial = (0, 0) tangential = (0, 0) rmean, tmean, rsigma, tsigma = (0, 0, 1, 1) else: wtaveg = self.weighted_average_angle_deg_from_tile(x) radial, tangential, rmean, tmean, rsigma, tsigma = get_radial_tangential_vectors( self, x) radial_sigmas[x] = rsigma tangen_sigmas[x] = tsigma table_data.append([ format_value("%3d", x), format_value("%7.2f", self.radii[x]), format_value("%6d", self.tilecounts[x]), format_value("%5.2f", self.asymmetric_tile_rmsd[x]), format_value("%5.2f", self.tile_rmsd[x]), format_value("%5.2f", self.mean_cv[x][0]), format_value("%5.2f", self.mean_cv[x][1]), format_value("%5.2f", matrix.col(self.mean_cv[x]).length()), format_value("%6.2f", wtaveg), format_value("%6.2f", rsigma), format_value("%6.2f", tsigma), ]) table_data.append([""] * len(table_header)) rstats = flex.mean_and_variance(radial_sigmas, self.tilecounts.as_double()) tstats = flex.mean_and_variance(tangen_sigmas, self.tilecounts.as_double()) table_data.append([ format_value("%3s", "ALL"), format_value("%s", ""), format_value("%6d", self.overall_N), format_value("%5.2f", math.sqrt(flex.mean(self.delrsq))), format_value("%5.2f", self.overall_rmsd), format_value("%5.2f", self.overall_cv[0]), format_value("%5.2f", self.overall_cv[1]), format_value( "%5.2f", flex.mean( flex.double( [matrix.col(cv).length() for cv in self.mean_cv]))), format_value("%s", ""), format_value("%6.2f", rstats.mean()), format_value("%6.2f", tstats.mean()), ]) print() print( table_utils.format(table_data, has_header=1, justify='center', delim=" "))
def _format_mean(values, format): return format_value(format=format, value=mean_default(values=values, default=None))
def show(self, log=None, prefix="", lowercase=False): if(log is None): log = sys.stdout def fmt(f1,f2,d1): fmt_str= "%6.3f %7.3f %6d" if f1 is None : return ' - - - ' return fmt_str%(f1,f2,d1) def fmt2(f1): if f1 is None: return ' - ' return "%-6.3f"%(f1) res = self.result() a,b,c,d,p,n = res.angle, res.bond, res.chirality, res.dihedral, \ res.planarity, res.nonbonded result = "%s" % prefix result += """ %sGEOMETRY RESTRAINTS LIBRARY: %s %sDEVIATIONS FROM IDEAL VALUES. %s BOND : %s %s ANGLE : %s %s CHIRALITY : %s %s PLANARITY : %s %s DIHEDRAL : %s %s MIN NONBONDED DISTANCE : %s %s"""%(prefix, self.restraints_source, prefix, prefix, fmt(b.mean, b.max, b.n), prefix, fmt(a.mean, a.max, a.n), prefix, fmt(c.mean, c.max, c.n), prefix, fmt(p.mean, p.max, p.n), prefix, fmt(d.mean, d.max, d.n), prefix, fmt2(n.min), prefix) result += "%s" % prefix result += """ %sMOLPROBITY STATISTICS. %s ALL-ATOM CLASHSCORE : %s %s RAMACHANDRAN PLOT: %s OUTLIERS : %-5.2f %s %s ALLOWED : %-5.2f %s %s FAVORED : %-5.2f %s %s ROTAMER OUTLIERS : %s %s %s CBETA DEVIATIONS : %-d %s PEPTIDE PLANE: %s CIS-PROLINE : %s %s CIS-GENERAL : %s %s TWISTED PROLINE : %s %s TWISTED GENERAL : %s"""%( prefix, prefix, format_value("%-6.2f", res.clash.score).strip(), prefix, prefix, res.ramachandran.outliers, "%", prefix, res.ramachandran.allowed, "%", prefix, res.ramachandran.favored, "%", prefix, str("%6.2f"%(res.rotamer.outliers)).strip(),"%", prefix, res.c_beta.outliers, prefix, prefix, str(res.omega.cis_proline), prefix, str(res.omega.cis_general), prefix, str(res.omega.twisted_proline), prefix, str(res.omega.twisted_general)) if(lowercase): result = result.swapcase() print >> log, result
def show(self, prefix="", log=None): self.assert_pdb_hierarchy_xray_structure_sync() if (log is None): log = sys.stdout fmt = """%s CC_mask: %-6.3f %s CC_volume: %-6.3f %s CC_peaks: %-6.3f %s rmsd (bonds): %-s %s rmsd (angles): %-s %s Dist. moved from start: %-6.3f %s Dist. moved from previous: %-6.3f %s All-atom clashscore %-s %s Ramachandran plot: %s outliers: %-s %% %s allowed: %-s %% %s favored: %-s %% %s Omega angle: %s cis-proline: %-s %% %s twisted proline: %-s %% %s cis-general: %-s %% %s twisted-general: %-s %% %s CaBLAM analysis: %s outliers: %-s %% %s disfavored: %-s %% %s ca outliers: %-s %% %s Rotamer outliers: %-s %% %s C-beta deviations: %-s %% """ mso = None try: if self.geometry_restraints_manager is not None and False: # XXX False at the end is intentional, because currently I want to # disable this 'if' branch. Reason is - nothing from extended # model_statistics (with GRM) is being used, so no reason to spend # time calculating statistics over various restraints. mso = mmtbx.model.statistics.geometry( pdb_hierarchy=self.pdb_hierarchy, molprobity_scores=libtbx.env.has_module("probe"), restraints_manager=self.geometry_restraints_manager) else: mso = mmtbx.model.statistics.geometry_no_grm( pdb_hierarchy=self.pdb_hierarchy, molprobity_scores=libtbx.env.has_module("probe")) except Exception: # some part of validation failed pass self.stats_evaluations.append( group_args(cc=group_args(cc_mask=self.five_cc.result.cc_mask, cc_volume=self.five_cc.result.cc_volume, cc_peaks=self.five_cc.result.cc_peaks), geometry=mso, rmsd_a=self.rmsd_a, rmsd_b=self.rmsd_b)) if mso is not None and self.five_cc is not None: print >> log, fmt % ( # prefix, self.map_cc_whole_unit_cell, # prefix, self.map_cc_around_atoms, prefix, self.five_cc.cc_mask, prefix, self.five_cc.cc_volume, prefix, self.five_cc.cc_peaks, prefix, format_value("%-6.2f", self.rmsd_b).strip(), prefix, format_value("%-6.2f", self.rmsd_a).strip(), prefix, self.dist_from_start, prefix, self.dist_from_previous, prefix, format_value("%-6.2f", mso.clashscore), prefix, prefix, format_value("%-5.2f", mso.ramachandran_outliers), prefix, format_value("%-5.2f", mso.ramachandran_allowed), prefix, format_value("%-5.2f", mso.ramachandran_favored), prefix, prefix, format_value("%-5.2f", mso.cis_proline), prefix, format_value("%-5.2f", mso.twisted_proline), prefix, format_value("%-5.2f", mso.cis_general), prefix, format_value("%-5.2f", mso.twisted_general), prefix, prefix, format_value("%-5.2f", mso.cablam_outliers), prefix, format_value("%-5.2f", mso.cablam_disfavored), prefix, format_value("%-5.2f", mso.cablam_ca_outliers), prefix, format_value("%6.2f", mso.rotamer_outliers).strip(), prefix, format_value("%-5.2f", mso.c_beta_dev_percent))
def fv(fs, val): return str_utils.format_value(fs, val, replace_none_with="---")
def run(args, left_offset=0.1, right_offset=0.1, n_bins=10): need_help_msg = False if (len(args) == 0): need_help_msg = True else: for arg in args: if (str(arg).lower() in ["help", "-h", "--help", "--h", "h"]): need_help_msg = True break if (need_help_msg): print(help_message) # def get_value(x): result = None try: result = float(x[x.index("=") + 1:]) except IndexError: pass except ValueError: pass return result d_min = None for arg in args: arg = str(arg).lower() try: d_min = float(arg) except ValueError: pass if (arg.count("left_offset")): x = get_value(arg) if (x is not None): left_offset = x if (arg.count("right_offset")): x = get_value(arg) if (x is not None): right_offset = x if (arg.count("n_bins")): x = int(get_value(arg)) if (x is not None): n_bins = x dl, dr = [0, 1.e+6] if (d_min is not None): cmd = "phenix.r_factor_statistics %s left_offset=%s right_offset=%s n_bins=%s" % ( format_value("%6.3f", d_min).strip(), format_value("%6.3f", left_offset).strip(), format_value("%6.3f", right_offset).strip(), format_value("%d", n_bins).strip()) print("Command used:\n\n%s\n\n" % cmd) dl = d_min - left_offset dr = d_min + right_offset file = libtbx.env.find_in_repositories( relative_path="chem_data/polygon_data/all_mvd.pickle", test=os.path.isfile) database_dict = easy_pickle.load(file) r_work_pdb = database_dict["pdb_header_r_work"] r_free_pdb = database_dict["pdb_header_r_free"] d_min = database_dict["high_resolution"] sel = r_work_pdb != "none" sel &= r_free_pdb != "none" sel &= d_min != "none" # r_work_pdb = r_work_pdb.select(sel) r_free_pdb = r_free_pdb.select(sel) d_min = d_min.select(sel) # def str_to_float(x): tmp = flex.double() for x_ in x: tmp.append(float(x_)) return tmp # d_min = str_to_float(d_min) r_work_pdb = str_to_float(r_work_pdb) r_free_pdb = str_to_float(r_free_pdb) diff = r_free_pdb - r_work_pdb # sel = d_min > dl sel &= d_min < dr sel &= diff > 0. sel &= diff < 0.1 # r_work_pdb = r_work_pdb.select(sel) r_free_pdb = r_free_pdb.select(sel) d_min = d_min.select(sel) diff = diff.select(sel) # print("Histogram of Rwork for models in PDB at resolution %4.2f-%4.2f A:" % (dl, dr)) show_histogram(data=r_work_pdb, n_slots=n_bins) print("Histogram of Rfree for models in PDB at resolution %4.2f-%4.2f A:" % (dl, dr)) show_histogram(data=r_free_pdb, n_slots=n_bins) print( "Histogram of Rfree-Rwork for all model in PDB at resolution %4.2f-%4.2f A:" % (dl, dr)) show_histogram(data=diff, n_slots=n_bins) print("Number of structures considered:", diff.size())
def __init__(self, data_arrays, xray_structure, log=None, silent=False, output_file=None, peak_search=False, map_cutoff=None, peak_search_params=None, r_free_arrays=None, write_map=True, multiscale=False, anomalous=False): if (log is None): log = sys.stdout adopt_init_args(self, locals()) fmodels = [] for i_seq, d in enumerate(data_arrays): if (not silent): print >> log, "Data set: %d" % i_seq if (d.anomalous_flag()) and (not anomalous): d = d.average_bijvoet_mates() elif (anomalous): assert d.anomalous_flag() if (r_free_arrays is not None) and (i_seq < len(r_free_arrays)): r_free_flags = r_free_arrays[i_seq] else: r_free_flags = d.array(data=flex.bool(d.data().size(), False)) fmodel = mmtbx.f_model.manager(xray_structure=xray_structure, r_free_flags=r_free_flags, target_name="ls_wunit_k1", f_obs=d) fmodel.update_all_scales(log=None) if (not silent): fmodel.info().show_rfactors_targets_scales_overall(out=log) print >> log fmodels.append(fmodel) self.fmodel = fmodels[0] # prepare Fobs for map calculation (apply scaling): f_obss = [] for fmodel in fmodels: obs = fmodel.f_obs() f_obs_scale = 1.0 / fmodel.k_anisotropic() / fmodel.k_isotropic() obs = miller.array(miller_set=fmodel.f_model(), data=obs.data() * f_obs_scale) f_obss.append(obs) # given two Fobs sets, make them one-to-one matching, get phases and map coefficients # Note: f_calc below is just f_calc from atoms (no bulk solvent etc applied) fobs_1, f_model = f_obss[0].common_sets(other=fmodels[1].f_model()) fobs_1, fobs_2 = fobs_1.common_sets(other=f_obss[1]) fobs_1, f_model = fobs_1.common_sets(other=f_model) self.f_model = f_model assert fobs_2.indices().all_eq(fobs_1.indices()) assert f_model.indices().all_eq(fobs_1.indices()) # scale again scale_k1 = 1 den = flex.sum(flex.abs(fobs_2.data()) * flex.abs(fobs_2.data())) if (den != 0): scale_k1 = flex.sum( flex.abs(fobs_1.data()) * flex.abs(fobs_2.data())) / den # fobs_2 = fobs_2.array(data=fobs_2.data() * scale_k1) if multiscale: fobs_1 = fobs_2.multiscale(other=fobs_1, reflections_per_bin=250) if (not silent): print >> log, "" print >> log, "Fobs1_vs_Fobs2 statistics:" print >> log, "Bin# Resolution range Compl. No.of refl. CC R-factor" fobs_1.setup_binner( reflections_per_bin=min(500, fobs_1.data().size())) fobs_2.use_binning_of(fobs_1) for i_bin in fobs_1.binner().range_used(): sel = fobs_1.binner().selection(i_bin) f1 = fobs_1.select(sel) f2 = fobs_2.select(sel) d_max, d_min = fobs_1.d_max_min() compl = fobs_1.completeness(d_max=d_max) n_ref = sel.count(True) num = flex.sum(flex.abs(f1.data() - f2.data())) den = flex.sum(flex.abs(f1.data() + f2.data()) / 2) r = None if (den != 0): r = num / den cc = flex.linear_correlation(x=f1.data(), y=f2.data()).coefficient() d_range = fobs_1.binner().bin_legend(i_bin=i_bin, show_bin_number=False, show_counts=False) fmt = "%3d: %-17s %4.2f %6d %5.3f %6s" print >> log, fmt % (i_bin, d_range, compl, n_ref, cc, format_value("%6.4f", r)) # overall statistics self.cc = flex.linear_correlation(x=fobs_1.data(), y=fobs_2.data()).coefficient() num = flex.sum(flex.abs(fobs_1.data() - fobs_2.data())) den = flex.sum(flex.abs(fobs_2.data() + fobs_2.data()) / 2) self.r_factor = None if (den != 0): self.r_factor = num / den # map coefficients def phase_transfer(miller_array, phase_source): tmp = miller.array( miller_set=miller_array, data=flex.double(miller_array.indices().size(), 1)).phase_transfer(phase_source=phase_source) return miller.array(miller_set=miller_array, data=miller_array.data() * tmp.data()) if (not anomalous): diff = miller.array(miller_set=f_model, data=fobs_1.data() - fobs_2.data()) self.map_coeff = phase_transfer(miller_array=diff, phase_source=f_model) else: dano_1 = fobs_1.anomalous_differences() dano_2 = fobs_2.anomalous_differences() assert dano_1.indices().all_eq(dano_2.indices()) diff = miller.array(miller_set=dano_1, data=dano_1.data() - dano_2.data()) f_model_phases = f_model.average_bijvoet_mates().common_set(diff) map_coeffs = phase_transfer(miller_array=diff, phase_source=f_model_phases) self.map_coeff = map_coeffs.customized_copy( data=map_coeffs.data() / (2j)) if (self.map_coeff.anomalous_flag()): self.map_coeff = map_coeff.average_bijvoet_mates() self.file_names = [] if (write_map): self.file_names = self.write_map_file()
def run_cc(params, reindexing_op, output): uniform, selected_uniform, have_iso_ref = load_cc_data( params, reindexing_op, output) NBIN = params.output.n_bins if have_iso_ref: slope, offset, corr_iso, N_iso = correlation(selected_uniform[1], selected_uniform[0], params.include_negatives) print("C.C. iso is %.1f%% on %d indices" % (100 * corr_iso, N_iso), file=output) slope, offset, corr_int, N_int = correlation(selected_uniform[2], selected_uniform[3], params.include_negatives) print("C.C. int is %.1f%% on %d indices" % (100. * corr_int, N_int), file=output) if have_iso_ref: binned_cc_ref, binned_cc_ref_N = binned_correlation( selected_uniform[1], selected_uniform[0], params.include_negatives) #binned_cc_ref.show(f=output) ref_scale = scale_factor(selected_uniform[1], selected_uniform[0], weights=flex.pow(selected_uniform[1].sigmas(), -2), use_binning=True) #ref_scale.show(f=output) ref_riso = r1_factor(selected_uniform[1], selected_uniform[0], scale_factor=ref_scale, use_binning=True) #ref_riso.show(f=output) ref_scale_all = scale_factor(selected_uniform[1], selected_uniform[0], weights=flex.pow( selected_uniform[1].sigmas(), -2)) ref_riso_all = r1_factor(selected_uniform[1], selected_uniform[0], scale_factor=ref_scale_all) binned_cc_int, binned_cc_int_N = binned_correlation( selected_uniform[2], selected_uniform[3], params.include_negatives) #binned_cc_int.show(f=output) oe_scale = scale_factor( selected_uniform[2], selected_uniform[3], weights=flex.pow(selected_uniform[2].sigmas(), -2) + flex.pow(selected_uniform[3].sigmas(), -2), use_binning=True) #oe_scale.show(f=output) oe_rint = r1_factor(selected_uniform[2], selected_uniform[3], scale_factor=oe_scale, use_binning=True) #oe_rint.show(f=output) oe_rsplit = r_split(selected_uniform[2], selected_uniform[3], use_binning=True) oe_scale_all = scale_factor( selected_uniform[2], selected_uniform[3], weights=flex.pow(selected_uniform[2].sigmas(), -2) + flex.pow(selected_uniform[3].sigmas(), -2), ) oe_rint_all = r1_factor(selected_uniform[2], selected_uniform[3], scale_factor=oe_scale_all) oe_rsplit_all = r_split(selected_uniform[2], selected_uniform[3]) if have_iso_ref: print("R factors Riso = %.1f%%, Rint = %.1f%%" % (100. * ref_riso_all, 100. * oe_rint_all), file=output) else: print("R factor Rint = %.1f%%" % (100. * oe_rint_all), file=output) split_sigma_data = split_sigma_test(selected_uniform[2], selected_uniform[3], scale=oe_scale, use_binning=True, show_plot=False) split_sigma_data_all = split_sigma_test(selected_uniform[2], selected_uniform[3], scale=oe_scale_all, use_binning=False, show_plot=False) print(file=output) if reindexing_op == "h,k,l": print("Table of Scaling Results:", file=output) else: print("Table of Scaling Results Reindexing as %s:" % reindexing_op, file=output) from libtbx import table_utils table_header = [ "", "", "", "CC", " N", "CC", " N", "R", "R", "R", "Scale", "Scale", "SpSig" ] table_header2 = [ "Bin", "Resolution Range", "Completeness", "int", "int", "iso", "iso", "int", "split", "iso", "int", "iso", "Test" ] table_data = [] table_data.append(table_header) table_data.append(table_header2) items = binned_cc_int.binner.range_used() # XXX Make it clear what the completeness here actually is! cumulative_counts_given = 0 cumulative_counts_complete = 0 for bin in items: table_row = [] table_row.append("%3d" % bin) table_row.append("%-13s" % binned_cc_int.binner.bin_legend(i_bin=bin, show_bin_number=False, show_bin_range=False, show_d_range=True, show_counts=False)) table_row.append("%13s" % binned_cc_int.binner.bin_legend(i_bin=bin, show_bin_number=False, show_bin_range=False, show_d_range=False, show_counts=True)) cumulative_counts_given += binned_cc_int.binner._counts_given[bin] cumulative_counts_complete += binned_cc_int.binner._counts_complete[ bin] table_row.append("%.1f%%" % (100. * binned_cc_int.data[bin])) table_row.append("%7d" % (binned_cc_int_N.data[bin])) if have_iso_ref and binned_cc_ref.data[bin] is not None: table_row.append("%.1f%%" % (100 * binned_cc_ref.data[bin])) else: table_row.append("--") if have_iso_ref and binned_cc_ref_N.data[bin] is not None: table_row.append("%6d" % (binned_cc_ref_N.data[bin])) else: table_row.append("--") if oe_rint.data[bin] is not None: table_row.append("%.1f%%" % (100. * oe_rint.data[bin])) else: table_row.append("--") if oe_rsplit.data[bin] is not None: table_row.append("%.1f%%" % (100 * oe_rsplit.data[bin])) else: table_row.append("--") if have_iso_ref and ref_riso.data[bin] is not None: table_row.append("%.1f%%" % (100 * ref_riso.data[bin])) else: table_row.append("--") if oe_scale.data[bin] is not None: table_row.append("%.3f" % oe_scale.data[bin]) else: table_row.append("--") if have_iso_ref and ref_scale.data[bin] is not None: table_row.append("%.3f" % ref_scale.data[bin]) else: table_row.append("--") if split_sigma_data.data[bin] is not None: table_row.append("%.4f" % split_sigma_data.data[bin]) else: table_row.append("--") table_data.append(table_row) table_data.append([""] * len(table_header)) table_row = [ format_value("%3s", "All"), format_value("%-13s", " "), format_value( "%13s", "[%d/%d]" % (cumulative_counts_given, cumulative_counts_complete)), format_value("%.1f%%", 100 * corr_int), format_value("%7d", N_int) ] if have_iso_ref: table_row.extend( (format_value("%.1f%%", 100 * corr_iso), format_value("%6d", N_iso))) else: table_row.extend(("--", "--")) table_row.extend((format_value("%.1f%%", 100 * oe_rint_all), format_value("%.1f%%", 100 * oe_rsplit_all))) if have_iso_ref: table_row.append(format_value("%.1f%%", 100 * ref_riso_all)) else: table_row.append("--") table_row.append(format_value("%.3f", oe_scale_all)) if have_iso_ref: table_row.append(format_value("%.3f", ref_scale_all)) else: table_row.append("--") if split_sigma_data_all is not None: table_row.append("%.1f" % split_sigma_data_all) else: table_row.append("--") table_data.append(table_row) print(file=output) print(table_utils.format(table_data, has_header=2, justify='center', delim=" "), file=output) print( """CCint is the CC-1/2 defined by Diederichs; correlation between odd/even images. Similarly, Scale int and R int are the scaling factor and scaling R factor between odd/even images. "iso" columns compare the whole XFEL dataset to the isomorphous reference.""", file=output) print("""Niso: result vs. reference common set""", end=' ', file=output) if params.include_negatives: print( """including negative merged intensities (set by phil parameter).""", file=output) elif params.scaling.log_cutoff is None: print(file=output) else: print("""with intensites < %7.2g filtered out (controlled by scaling.log_cutoff phil parameter set to %5.1f)""" % (math.exp(params.scaling.log_cutoff), params.scaling.log_cutoff), file=output) if have_iso_ref: assert N_iso == flex.sum( flex.double([x for x in binned_cc_ref_N.data if x is not None])) assert N_int == flex.sum( flex.double([x for x in binned_cc_int_N.data if x is not None])) if params.scaling.show_plots: from matplotlib import pyplot as plt plt.plot(flex.log(selected_uniform[-2].data()), flex.log(selected_uniform[-1].data()), 'r.') plt.show() if have_iso_ref: plt.plot(flex.log(selected_uniform[0].data()), flex.log(selected_uniform[1].data()), 'r.') plt.show() print(file=output)