def plot_positions(values, positions, file_name, cmap=pyplot.cm.Reds, vmin=None, vmax=None, invalid='white'): values = values.as_double() assert positions.size() >= values.size() positions = positions[:values.size()] if vmin is None: vmin = flex.min(values) if vmax is None: vmax = flex.max(values) x, y = positions.parts() dx = flex.abs(x[1:] - x[:-1]) dy = flex.abs(y[1:] - y[:-1]) dx = dx.select(dx > 0) dy = dy.select(dy > 0) scale = 1/flex.min(dx) #print scale x = (x * scale).iround() y = (y * scale).iround() from libtbx.math_utils import iceil z = flex.double(flex.grid(iceil(flex.max(y))+1, iceil(flex.max(x))+1), -2) #print z.all() for x_, y_, z_ in zip(x, y, values): z[y_, x_] = z_ plot_grid(z.as_1d(), z.all(), file_name, cmap=cmap, vmin=vmin, vmax=vmax, invalid=invalid) return
def __init__(self, intensities, dose, n_bins=8, range_min=None, range_max=None, range_width=1): self.intensities = intensities self.dose = dose self.n_bins = n_bins self.range_min = range_min self.range_max = range_max self.range_width = range_width assert self.range_width > 0 if self.range_min is None: self.range_min = flex.min(self.dose) - self.range_width if self.range_max is None: self.range_max = flex.max(self.dose) self.n_steps = 2 + int((self.range_max - self.range_min) - self.range_width) sel = (self.dose.as_double() <= self.range_max) & (self.dose.as_double() >= self.range_min) self.dose = self.dose.select(sel) self.intensities = self.intensities.select(sel) self.d_star_sq = self.intensities.d_star_sq().data() self.binner = self.intensities.setup_binner_d_star_sq_step( d_star_sq_step=(flex.max(self.d_star_sq)-flex.min(self.d_star_sq)+1e-8)/self.n_bins) self.observations = unmerged_observations(self.intensities) self._calc_completeness_vs_dose() self._calc_rcp_scp() self._calc_rd()
def minimize_kbu(self, n_cycles=10): #print "minimize_kbu start r:", self.kbu.r_factor() for use_curvatures in [False, True] * n_cycles: #print " minimize_kbu r:", self.kbu.r_factor() start_r = self.kbu.r_factor() save_k_sols = self.kbu.k_sols() save_b_sols = self.kbu.b_sols() save_b_cart = self.kbu.b_cart() #self.set_use_scale(value = random.choice([True, False])) self.set_use_scale(value=True) m = self.minimize_kb_once(use_curvatures=use_curvatures) r = self.kbu.r_factor() if (r > start_r and r > 1.e-2 and (flex.min(self.kbu.k_sols()) < 0 or flex.max(self.kbu.k_sols()) > 1 or flex.min(self.kbu.b_sols()) < 0 or flex.max(self.kbu.k_sols()) > 100.)): self.kbu.update(k_sols=save_k_sols, b_sols=save_b_sols) # assert m.minimizer.n_calls == m.minimizer.nfun() m = self.minimize_u_once() # assert m.minimizer.n_calls == m.minimizer.nfun() r = self.kbu.r_factor() bc = list(flex.abs(flex.double(self.kbu.b_cart()))) if (r > start_r and r > 1.e-2 and max(bc) > 100): self.kbu.update(b_cart=save_b_cart) break
def show_refinement_update(fmodels, selection, da_sel_refinable, prefix): fmt1 = "%s Rwork= %8.6f Rfree= %8.6f Number of: non-DA= %d DA= %d all= %d" print(fmt1 % (prefix, fmodels.fmodel_xray().r_work(), fmodels.fmodel_xray().r_free(), selection.count(False), selection.count(True), fmodels.fmodel_xray().xray_structure.scatterers().size())) occ = fmodels.fmodel_xray().xray_structure.scatterers( ).extract_occupancies() occ_da = occ.select(selection) if (occ_da.size() > 0): occ_ma = occ.select(~selection) print(" non-da: occ(min,max,mean)= %6.3f %6.3f %6.3f" % (flex.min(occ_ma), flex.max(occ_ma), flex.mean(occ_ma))) print(" da: occ(min,max,mean)= %6.3f %6.3f %6.3f" % (flex.min(occ_da), flex.max(occ_da), flex.mean(occ_da))) b = fmodels.fmodel_xray().xray_structure.extract_u_iso_or_u_equiv()*\ adptbx.u_as_b(1.) b_da = b.select(selection) b_ma = b.select(~selection) print(" non-da: ADP(min,max,mean)= %7.2f %7.2f %7.2f" % (flex.min(b_ma), flex.max(b_ma), flex.mean(b_ma))) print(" da: ADP(min,max,mean)= %7.2f %7.2f %7.2f" % (flex.min(b_da), flex.max(b_da), flex.mean(b_da))) print("da_sel_refinable:", da_sel_refinable.size(), da_sel_refinable.count(True))
def write_json(filename, x,y1, y2=None): out=open(filename, 'w') head = '{"elements":[' ele1 = '{"type": "line", "dot-style":{"type": "dot", "dot-size": 3, "colour":"#DFC329"}, "width":3, "colour": "DFC329", "text":"model", "font-size":10,' print>>out, head, ele1, '"values":', y1 = flex.log(flex.abs(y1)+1e-16 ) y_min=flex.min(y1)-1.0 y_max=flex.max(y1)+1.0 print>>out, '[' + ', '.join('%5.6f' % v for v in y1) + ']', # for xx, yy in zip( x[:-2], y1[:-2]): #print>>out,'{"x":%f, "y":%f},'%(xx,yy), # print>>out,'{"x":%f, "y":%f}'%(x[-1],y1[-1]), print>>out, '}', # end of y1 if(y2 is not None): ele2 = ',{"type": "line", "dot-style":{"type": "dot", "dot-size": 1, "colour":"#111111"}, "width":1, "colour": "111111", "text":"expt", "font-size":10,' print>>out, ele2, '"values":', y2 = flex.log(flex.abs(y2)+1e-16) y_min=min(flex.min(y2)-1.0, y_min) y_max=max(flex.max(y2)+1.0, y_max) print>>out, '[' + ', '.join('%5.6f' % v for v in y2) + ']', print>>out, '}', # end of y2 print>>out, ']', # end of elements ### now setup axis ### print>>out,',"y_axis":{"min":%f, "max":%f}'%(y_min, y_max), steps = int(0.05/(x[1]-x[0])) x_labels = '["' for xx in x: x_labels = x_labels + str(xx) + '","' x_labels=x_labels[0:-2]+']' print>>out,',"x_axis":{"min":%d, "max":%d, "steps":%d, "labels":{"labels":%s,"steps":%d}}'%(0,x.size(),steps,x_labels, steps), print>>out,'}' ##end of the file out.close()
def branch_3_mn(): m = None n = None small = 1.e-15 for i in range(10000): m2 = [] n2 = [] for i in range(4): r1 = random.random() r2 = random.random() r3 = random.random() if (r3 > 0.1): r1 = r2 m2.append(r1) n2.append(r2) p1 = 0.5 * (m2[0] + m2[3] + math.sqrt(4 * m2[1] * m2[2] + (m2[0] - m2[3])**2)) p2 = 0.5 * (m2[0] + m2[3] - math.sqrt(4 * m2[1] * m2[2] + (m2[0] - m2[3])**2)) q1 = 0.5 * (n2[0] + m2[3] + math.sqrt(4 * n2[1] * n2[2] + (n2[0] - n2[3])**2)) q2 = 0.5 * (n2[0] + m2[3] - math.sqrt(4 * n2[1] * n2[2] + (n2[0] - n2[3])**2)) if (min(p1, p2) > 0.0 and min(q1, q2) > 0.0): r = random.random() if (r > 0.5): r1 = r3 r2 = r2 m = [m2[0], m2[3], r1, m2[1], 0, 0] n = [n2[0], n2[3], r2, n2[1], 0, 0] if ([ adptbx.is_positive_definite(m), adptbx.is_positive_definite(n) ].count(True) == 2): esm = adptbx.eigensystem(m) esn = adptbx.eigensystem(n) vn = esn.values() vm = esm.values() mmin = flex.min(flex.double(vm)) nmin = flex.min(flex.double(vn)) if (abs(abs(mmin) - abs(nmin)) < small and mmin > 0. and nmin > 0.): for i, v in enumerate(vn): if (abs(abs(nmin) - v) < small): break for j, v in enumerate(vm): if (abs(abs(mmin) - v) < small): break vecn = flex.double(esn.vectors(i)) vecm = flex.double(esm.vectors(j)) if (flex.mean(vecm - vecn) < small): break else: m = None n = None assert [m, n] != [None, None] assert [adptbx.is_positive_definite(m), adptbx.is_positive_definite(n)].count(True) == 2 r = random.random() if (r > 0.5): m = adptbx.random_rotate_ellipsoid(u_cart=m) n = adptbx.random_rotate_ellipsoid(u_cart=n) return m, n
def miller_array_export_as_shelx_hklf( miller_array, file_object=None, normalise_if_format_overflow=False): """\ If the maximum data value does not fit into the f8.2/f8.0 format: normalise_if_format_overflow=False: RuntimeError is thrown normalise_if_format_overflow=True: data is normalised to the largest number to fit f8.2/f8.0 format """ assert miller_array.is_real_array() if (file_object is None): file_object = sys.stdout def raise_f8_overflow(v): raise RuntimeError("SHELX HKL file F8.2/F8.0 format overflow: %.8g" % v) data = miller_array.data() sigmas = miller_array.sigmas() assert data is not None min_val = flex.min(data) max_val = flex.max(data) if (sigmas is not None): min_val = min(min_val, flex.min(sigmas)) max_val = max(max_val, flex.max(sigmas)) min_sc = 1 max_sc = 1 if (min_val < 0): s = "%8.0f" % min_val if (len(s) > 8): if (not normalise_if_format_overflow): raise_f8_overflow(min_val) min_sc = -9999999. / min_val if (max_val > 0): s = "%8.0f" % max_val if (len(s) > 8): if (not normalise_if_format_overflow): raise_f8_overflow(max_val) max_sc = 99999999. / max_val scale = min(min_sc, max_sc) sigmas = miller_array.sigmas() s = 0.01 for i,h in enumerate(miller_array.indices()): if (sigmas is not None): s = sigmas[i] def fmt_3i4(h): result = "%4d%4d%4d" % h if (len(result) != 12): raise RuntimeError( "SHELXL HKL file 3I4 format overflow: %s" % result) return result def fmt_f8(v): result = "%8.2f" % v if (len(result) != 8): result = "%8.1f" % v if (len(result) != 8): result = "%8.0f" % v assert len(result) == 8 return result line = fmt_3i4(h) + fmt_f8(data[i]*scale) + fmt_f8(s*scale) print >> file_object, line print >> file_object, " 0 0 0 0.00 0.00"
def show_histogram(data, n_slots): print flex.min(data), flex.max(data), flex.mean(data) hm = flex.histogram(data = data, n_slots = n_slots) lc_1 = hm.data_min() s_1 = enumerate(hm.slots()) for (i_1,n_1) in s_1: hc_1 = hm.data_min() + hm.slot_width() * (i_1+1) print "%10.3f - %-10.3f : %10.2f" % (lc_1, hc_1, float(n_1)/(data.size())*100.) lc_1 = hc_1
def show_histogram(data, n_slots): print flex.min(data), flex.max(data), flex.mean(data) hm = flex.histogram(data=data, n_slots=n_slots) lc_1 = hm.data_min() s_1 = enumerate(hm.slots()) for (i_1, n_1) in s_1: hc_1 = hm.data_min() + hm.slot_width() * (i_1 + 1) print "%10.3f - %-10.3f : %10.2f" % (lc_1, hc_1, float(n_1) / (data.size()) * 100.) lc_1 = hc_1
def resolution_i_mean_over_sigma_mean(self, limit=None): """Compute a resolution limit where either <I>/<sigma> = 1.0 (limit if set) or the full extent of the data.""" if limit is None: limit = self._params.i_mean_over_sigma_mean isigma_s = flex.double([ b.i_mean_over_sigi_mean for b in self._merging_statistics.bins ]).reversed() s_s = flex.double([ 1 / b.d_min**2 for b in self._merging_statistics.bins ]).reversed() sel = isigma_s > 0 isigma_s = isigma_s.select(sel) s_s = s_s.select(sel) if flex.min(isigma_s) > limit: r_isigma = 1.0 / math.sqrt(flex.max(s_s)) isigma_f = None else: isigma_f = log_fit(s_s, isigma_s, 6) logger.debug( "isigma: fits\n%s", tabulate( [("d*2", "d", "isigma_s", "isigma_f")] + [(s, 1.0 / math.sqrt(s), isigma_s[j], isigma_f[j]) for j, s in enumerate(s_s)], headers="firstrow", ), ) try: r_isigma = 1.0 / math.sqrt( interpolate_value(s_s, isigma_f, limit)) except Exception: if limit > max(isigma_f): r_isigma = 1.0 / math.sqrt(flex.min(s_s)) else: r_isigma = 1.0 / math.sqrt(flex.max(s_s)) if self._params.plot: plot = resolution_plot(ylabel="Unmerged <I>/<sigma>") if isigma_f is not None: plot.plot(s_s, isigma_f, label="fit") plot.plot(s_s, isigma_s, label="Unmerged <I>/<sigma>") plot.plot_resolution_limit(r_isigma) plot.savefig("i_mean_over_sigma_mean.png") return r_isigma
def branch_3_mn(): m = None n = None small = 1.e-15 for i in xrange(10000): m2=[] n2=[] for i in xrange(4): r1 = random.random() r2 = random.random() r3 = random.random() if(r3 > 0.1): r1 = r2 m2.append(r1) n2.append(r2) p1 = 0.5 * (m2[0]+m2[3] + math.sqrt(4*m2[1]*m2[2]+(m2[0]-m2[3])**2)) p2 = 0.5 * (m2[0]+m2[3] - math.sqrt(4*m2[1]*m2[2]+(m2[0]-m2[3])**2)) q1 = 0.5 * (n2[0]+m2[3] + math.sqrt(4*n2[1]*n2[2]+(n2[0]-n2[3])**2)) q2 = 0.5 * (n2[0]+m2[3] - math.sqrt(4*n2[1]*n2[2]+(n2[0]-n2[3])**2)) if(min(p1,p2) > 0.0 and min(q1,q2) > 0.0): r = random.random() if(r > 0.5): r1 = r3 r2 = r2 m = [m2[0],m2[3],r1,m2[1],0,0] n = [n2[0],n2[3],r2,n2[1],0,0] if([adptbx.is_positive_definite(m), adptbx.is_positive_definite(n)].count(True)==2): esm = adptbx.eigensystem(m) esn = adptbx.eigensystem(n) vn = esn.values() vm = esm.values() mmin = flex.min(flex.double(vm)) nmin = flex.min(flex.double(vn)) if(abs(abs(mmin) - abs(nmin)) < small and mmin> 0. and nmin> 0.): for i, v in enumerate(vn): if(abs(abs(nmin) - v) < small): break for j, v in enumerate(vm): if(abs(abs(mmin) - v) < small): break vecn = flex.double(esn.vectors(i)) vecm = flex.double(esm.vectors(j)) if(flex.mean(vecm-vecn) < small): break else: m = None n = None assert [m,n] != [None,None] assert [adptbx.is_positive_definite(m), adptbx.is_positive_definite(n)].count(True)==2 r = random.random() if(r > 0.5): m = adptbx.random_rotate_ellipsoid(u_cart = m) n = adptbx.random_rotate_ellipsoid(u_cart = n) return m,n
def solvent_adjust(self): if not self.params.solvent_adjust: return min_solvent_density = flex.min(self.map.select(self.solvent_iselection)) min_protein_density = flex.min(self.map.select(self.protein_iselection)) self.solvent_add = ((self.mean_protein_density-min_protein_density) /self.params.protein_solvent_ratio) \ + min_protein_density - self.mean_solvent_density self.map.as_1d().copy_selected( self.solvent_iselection, (self.map + self.solvent_add).as_1d()) #self.mean_solvent_density = flex.mean(self.map.select(self.solvent_iselection)) self.mean_solvent_density = (1-self.params.solvent_fraction) \ * (self.mean_solvent_density+self.solvent_add-self.mean_protein_density)
def resolution_i_mean_over_sigma_mean(self, limit=None, log=None): """Compute a resolution limit where either <I>/<sigma> = 1.0 (limit if set) or the full extent of the data.""" if limit is None: limit = self._params.i_mean_over_sigma_mean isigma_s = flex.double([ b.i_mean_over_sigi_mean for b in self._merging_statistics.bins ]).reversed() s_s = flex.double([ 1 / b.d_min**2 for b in self._merging_statistics.bins ]).reversed() sel = isigma_s > 0 isigma_s = isigma_s.select(sel) s_s = s_s.select(sel) if flex.min(isigma_s) > limit: r_isigma = 1.0 / math.sqrt(flex.max(s_s)) isigma_f = None else: isigma_f = log_fit(s_s, isigma_s, 6) if log: fout = open(log, "w") for j, s in enumerate(s_s): d = 1.0 / math.sqrt(s) o = isigma_s[j] m = isigma_f[j] fout.write("%f %f %f %f\n" % (s, d, o, m)) fout.close() try: r_isigma = 1.0 / math.sqrt( interpolate_value(s_s, isigma_f, limit)) except Exception: if limit > max(isigma_f): r_isigma = 1.0 / math.sqrt(flex.min(s_s)) else: r_isigma = 1.0 / math.sqrt(flex.max(s_s)) if self._params.plot: plot = resolution_plot(ylabel="Unmerged <I>/<sigma>") if isigma_f is not None: plot.plot(s_s, isigma_f, label="fit") plot.plot(s_s, isigma_s, label="Unmerged <I>/<sigma>") plot.plot_resolution_limit(r_isigma) plot.savefig("i_mean_over_sigma_mean.png") return r_isigma
def minimize_kb(self, use_curvatures_options, set_use_scale_options=[True, False], n_cycles=5): #print "minimize_kb, r:", self.kbu.r_factor() for use_curvatures in use_curvatures_options*n_cycles: start_r = self.kbu.r_factor() save_k_sols = self.kbu.k_sols() save_b_sols = self.kbu.b_sols() #self.set_use_scale(value = random.choice(set_use_scale_options)) self.set_use_scale(value = True) m = self.minimize_kb_once(use_curvatures=use_curvatures) r = self.kbu.r_factor() if(r>start_r and r>1.e-2 and (flex.min(self.kbu.k_sols())<0 or flex.max(self.kbu.k_sols())>1 or flex.min(self.kbu.b_sols())<0 or flex.max(self.kbu.k_sols())>100.)): self.kbu.update(k_sols = save_k_sols, b_sols = save_b_sols)
def show_xray_structure_statistics(xray_structure, atom_selections, hd_sel=None): result = group_args(all=None, macromolecule=None, sidechain=None, solvent=None, ligand=None, backbone=None) if (hd_sel is not None): xray_structure = xray_structure.select(~hd_sel) for key in atom_selections.__dict__.keys(): value = atom_selections.__dict__[key] if (value.count(True) > 0): if (hd_sel is not None): value = value.select(~hd_sel) xrs = xray_structure.select(value) atom_counts = xrs.scattering_types_counts_and_occupancy_sums() atom_counts_strs = [] for ac in atom_counts: atom_counts_strs.append( "%s:%s:%s" % (ac.scattering_type, str( ac.count), str("%10.2f" % ac.occupancy_sum).strip())) atom_counts_str = " ".join(atom_counts_strs) b_isos = xrs.extract_u_iso_or_u_equiv() n_aniso = xrs.use_u_aniso().count(True) n_not_positive_definite = xrs.is_positive_definite_u().count(False) b_mean = format_value("%-6.1f", adptbx.u_as_b(flex.mean(b_isos))) b_min = format_value("%-6.1f", adptbx.u_as_b(flex.min(b_isos))) b_max = format_value("%-6.1f", adptbx.u_as_b(flex.max(b_isos))) n_atoms = format_value("%-8d", xrs.scatterers().size()).strip() n_npd = format_value("%-8s", n_not_positive_definite).strip() occ = xrs.scatterers().extract_occupancies() o_mean = format_value("%-6.2f", flex.mean(occ)).strip() o_min = format_value("%-6.2f", flex.min(occ)).strip() o_max = format_value("%-6.2f", flex.max(occ)).strip() tmp_result = group_args(n_atoms=n_atoms, atom_counts_str=atom_counts_str, b_min=b_min, b_max=b_max, b_mean=b_mean, o_min=o_min, o_max=o_max, o_mean=o_mean, n_aniso=n_aniso, n_npd=n_npd) setattr(result, key, tmp_result) return result
def i_sig_i_vs_batch(intensities, batches): assert intensities.size() == batches.size() assert intensities.sigmas() is not None sel = intensities.sigmas() > 0 i_sig_i = intensities.data().select(sel) / intensities.sigmas().select(sel) batches = batches.select(sel) bins = [] data = [] perm = flex.sort_permutation(batches.data()) batches = batches.data().select(perm) i_sig_i = i_sig_i.select(perm) i_batch_start = 0 current_batch = flex.min(batches) n_ref = batches.size() for i_ref in range(n_ref + 1): if i_ref == n_ref or batches[i_ref] != current_batch: assert batches[i_batch_start:i_ref].all_eq(current_batch) data.append(flex.mean(i_sig_i[i_batch_start:i_ref])) bins.append(current_batch) i_batch_start = i_ref if i_ref < n_ref: current_batch = batches[i_batch_start] return batch_binned_data(bins, data)
def filter_mask(mask_p1, volume_cutoff, crystal_symmetry, for_structure_factors=False): co = maptbx.connectivity(map_data=mask_p1, threshold=0.01, preprocess_against_shallow=True, wrapping=True) mi, ma = flex.min(mask_p1), flex.max(mask_p1) print(mask_p1.size(), (mask_p1 < 0).count(True)) assert mi == 0, mi assert ma == 1, ma a, b, c = crystal_symmetry.unit_cell().parameters()[:3] na, nb, nc = mask_p1.accessor().all() step = flex.mean(flex.double([a / na, b / nb, c / nc])) if (crystal_symmetry.space_group_number() != 1): co.merge_symmetry_related_regions( space_group=crystal_symmetry.space_group()) conn = co.result().as_double() z = zip(co.regions(), range(0, co.regions().size())) sorted_by_volume = sorted(z, key=lambda x: x[0], reverse=True) for i_seq, p in enumerate(sorted_by_volume): v, i = p if (i == 0): continue # skip macromolecule # skip small volume volume = v * step**3 if volume < volume_cutoff: conn = conn.set_selected(conn == i, 0) conn = conn.set_selected(conn > 0, 1) if for_structure_factors: conn = conn / crystal_symmetry.space_group().order_z() return conn
def quick_test(file_name): from libtbx.utils import user_plus_sys_time t = user_plus_sys_time() s = reader(file_name) print "Time read:", t.delta() s.show_summary() print tuple(s.original_indices[:3]) print tuple(s.unique_indices[:3]) print tuple(s.batch_numbers[:3]) print tuple(s.centric_tags[:3]) print tuple(s.spindle_flags[:3]) print tuple(s.asymmetric_unit_indices[:3]) print tuple(s.i_obs[:3]) print tuple(s.sigmas[:3]) print tuple(s.original_indices[-3:]) print tuple(s.unique_indices[-3:]) print tuple(s.batch_numbers[-3:]) print tuple(s.centric_tags[-3:]) print tuple(s.spindle_flags[-3:]) print tuple(s.asymmetric_unit_indices[-3:]) print tuple(s.i_obs[-3:]) print tuple(s.sigmas[-3:]) m = s.as_miller_array(merge_equivalents=False).merge_equivalents() print "min redundancies:", flex.min(m.redundancies().data()) print "max redundancies:", flex.max(m.redundancies().data()) print "mean redundancies:", flex.mean(m.redundancies().data().as_double()) s.as_miller_arrays()[0].show_summary() print
def suggest_likely_candidates( self, acceptable_violations = 1e+90 ): used = flex.bool( len(self.sg_choices), False ) order = [] all_done = False count = -1 if (len(self.tuple_score) == 0) : return [] tmp_scores = [] for tt in self.tuple_score: tmp_scores.append( tt[0] ) order = flex.sort_permutation( flex.double( tmp_scores ), False ) sorted_rows = [] max_score = flex.min( flex.double( tmp_scores ) ) for ii in order: sg = self.sg_choices[ii] tmp_n = self.n[ii] tmp_violations = self.violations[ii] tmp_mean_i = self.mean_i[ii] tmp_mean_isigi = self.mean_isigi[ii] tuple_score = self.tuple_score[ii] sorted_rows.append( [str(sg), '%i'%(tmp_n), '%8.2f '%(tmp_mean_i), '%8.2f '%(tmp_mean_isigi), ' %i '%(tuple_score[1]), ' %i '%(tuple_score[2]), ' %8.3e '%((tuple_score[0]-max_score)) ]) return sorted_rows
def __init__(self, f_obs, ncs_pairs, reflections_per_bin): adopt_init_args(self, locals()) # Create bins f_obs.setup_binner(reflections_per_bin = reflections_per_bin) self.binner = f_obs.binner() n_bins = self.binner.n_bins_used() self.n_bins = n_bins self.SigmaN = None self.update_SigmaN() # self.rbin = flex.int(f_obs.data().size(), -1) for i_bin in self.binner.range_used(): for i_seq in self.binner.array_indices(i_bin): self.rbin[i_seq] = i_bin-1 # i_bin starts with 1, not 0 ! assert flex.min(self.rbin)==0 assert flex.max(self.rbin)==n_bins-1 # Extract symmetry matrices self.sym_matrices = [] for m_as_string in f_obs.space_group().smx(): o = sgtbx.rt_mx(symbol=str(m_as_string), t_den=f_obs.space_group().t_den()) m_as_double = o.r().as_double() self.sym_matrices.append(m_as_double) self.gradient_evaluator = None self.target_and_grads = ext.tncs_eps_factor_refinery( tncs_pairs = self.ncs_pairs, f_obs = self.f_obs.data(), sigma_f_obs = self.f_obs.sigmas(), rbin = self.rbin, SigmaN = self.SigmaN, space_group = self.f_obs.space_group(), miller_indices = self.f_obs.indices(), fractionalization_matrix = self.f_obs.unit_cell().fractionalization_matrix(), sym_matrices = self.sym_matrices) self.update()
def set_refinable_parameters(xray_structure, parameters, selections, enforce_positivity=False): # XXX PVA: Code below is terribly inefficient and MUST be moved into C++ sz = xray_structure.scatterers().size() i = 0 for sel in selections: # pre-check for positivity begin # spread negative occupancies across i_seqs having positive ones par_all = flex.double() par_neg = flex.double() i_p = i for sel_ in sel: p = parameters[i_p] par_all.append(p) if(p<0): par_neg.append(p) i_p += 1 if(enforce_positivity and par_neg.size()>0): par_all = par_all - flex.min(par_all) fs = flex.sum(par_all) if(fs != 0): par_all = par_all / fs # pre-check for positivity end for j, sel_ in enumerate(sel): sel__b = flex.bool(sz, flex.size_t(sel_)) xray_structure.set_occupancies(par_all[j], sel__b) i+=1
def target_and_gradients(self, xray_structure, to_compute_weight=False): if(to_compute_weight): xrs = xray_structure.deep_copy_scatterers() # This may be useful to explore: #xrs.shake_adp_if_all_equal(b_iso_tolerance = 1.e-3) #xrs.shake_adp(spread=10, keep_anisotropic= False) else: xrs = xray_structure if(self.refine_adp): params = xrs.extract_u_iso_or_u_equiv() if(self.refine_occ): params = xrs.scatterers().extract_occupancies() if(to_compute_weight): pmin = flex.min(params) pmax = flex.max(params) if(abs(pmin-pmax)/abs(pmin+pmax)*2*100<1.e-3): pmean = flex.mean(params) n_par = params.size() params = flex.double() for i in xrange(n_par): params.append(pmean + 0.1 * pmean * random.choice([-1,0,1])) return crystal.adp_iso_local_sphere_restraints_energies( pair_sym_table = self.pair_sym_table, orthogonalization_matrix = self.orthogonalization_matrix, sites_frac = self.sites_frac, u_isos = params, selection = self.selection, use_u_iso = self.selection, grad_u_iso = self.selection, sphere_radius = self.sphere_radius, distance_power = 2, average_power = 1, min_u_sum = 1.e-6, compute_gradients = True, collect = False)
def target_and_gradients(self, xray_structure, to_compute_weight=False): if (to_compute_weight): xrs = xray_structure.deep_copy_scatterers() # This may be useful to explore: #xrs.shake_adp_if_all_equal(b_iso_tolerance = 1.e-3) #xrs.shake_adp(spread=10, keep_anisotropic= False) else: xrs = xray_structure if (self.refine_adp): params = xrs.extract_u_iso_or_u_equiv() if (self.refine_occ): params = xrs.scatterers().extract_occupancies() if (to_compute_weight): pmin = flex.min(params) pmax = flex.max(params) if (abs(pmin + pmax) != 0. and abs(pmin - pmax) / abs(pmin + pmax) * 2 * 100 < 1.e-3): pmean = flex.mean(params) n_par = params.size() params = flex.double() for i in range(n_par): params.append(pmean + 0.1 * pmean * random.choice([-1, 0, 1])) return crystal.adp_iso_local_sphere_restraints_energies( pair_sym_table=self.pair_sym_table, orthogonalization_matrix=self.orthogonalization_matrix, sites_frac=self.sites_frac, u_isos=params, selection=self.selection, use_u_iso=self.selection, grad_u_iso=self.selection, sphere_radius=self.sphere_radius, distance_power=2, average_power=1, min_u_sum=1.e-6, compute_gradients=True, collect=False)
def histogram(self): normalised_score = self._normalised_delta_cc_i() return { "delta_cc_half_histogram": { "data": [{ "x": list(normalised_score), "xbins": { "start": math.floor(flex.min(normalised_score)), "end": math.ceil(flex.max(normalised_score)) + 1, "size": 0.1, }, "type": "histogram", "name": u"Delta CC<sub>½</sub>", }], "layout": { "title": u"Histogram of Delta CC<sub>½</sub>", "xaxis": { "title": u"σ" }, "yaxis": { "title": "Frequency" }, }, } }
def get_map(): av = [random.random() for i in xrange(10*20*30)] m = flex.double(av) m = m-flex.min(m) m = m/flex.max(m) m.resize(flex.grid((10,20,30))) return m
def quick_test(file_name): from libtbx.utils import user_plus_sys_time t = user_plus_sys_time() s = reader(file_name) print("Time read:", t.delta()) s.show_summary() print(tuple(s.original_indices[:3])) print(tuple(s.unique_indices[:3])) print(tuple(s.batch_numbers[:3])) print(tuple(s.centric_tags[:3])) print(tuple(s.spindle_flags[:3])) print(tuple(s.asymmetric_unit_indices[:3])) print(tuple(s.i_obs[:3])) print(tuple(s.sigmas[:3])) print(tuple(s.original_indices[-3:])) print(tuple(s.unique_indices[-3:])) print(tuple(s.batch_numbers[-3:])) print(tuple(s.centric_tags[-3:])) print(tuple(s.spindle_flags[-3:])) print(tuple(s.asymmetric_unit_indices[-3:])) print(tuple(s.i_obs[-3:])) print(tuple(s.sigmas[-3:])) m = s.as_miller_array(merge_equivalents=False).merge_equivalents() print("min redundancies:", flex.min(m.redundancies().data())) print("max redundancies:", flex.max(m.redundancies().data())) print("mean redundancies:", flex.mean(m.redundancies().data().as_double())) s.as_miller_arrays()[0].show_summary() print()
def suggest_likely_candidates(self, acceptable_violations=1e+90): used = flex.bool(len(self.sg_choices), False) order = [] all_done = False count = -1 if (len(self.tuple_score) == 0): return [] tmp_scores = [] for tt in self.tuple_score: tmp_scores.append(tt[0]) order = flex.sort_permutation(flex.double(tmp_scores), False) sorted_rows = [] max_score = flex.min(flex.double(tmp_scores)) for ii in order: sg = self.sg_choices[ii] tmp_n = self.n[ii] tmp_violations = self.violations[ii] tmp_mean_i = self.mean_i[ii] tmp_mean_isigi = self.mean_isigi[ii] tuple_score = self.tuple_score[ii] sorted_rows.append([ str(sg), '%i' % (tmp_n), '%8.2f ' % (tmp_mean_i), '%8.2f ' % (tmp_mean_isigi), ' %i ' % (tuple_score[1]), ' %i ' % (tuple_score[2]), ' %8.3e ' % ((tuple_score[0] - max_score)) ]) return sorted_rows
def show_xray_structure_statistics(xray_structure, atom_selections, hd_sel = None): result = group_args( all = None, macromolecule = None, sidechain = None, solvent = None, ligand = None, backbone = None) if(hd_sel is not None): xray_structure = xray_structure.select(~hd_sel) for key in atom_selections.__dict__.keys(): value = atom_selections.__dict__[key] if(value.count(True) > 0): if(hd_sel is not None): value = value.select(~hd_sel) xrs = xray_structure.select(value) atom_counts = xrs.scattering_types_counts_and_occupancy_sums() atom_counts_strs = [] for ac in atom_counts: atom_counts_strs.append("%s:%s:%s"%(ac.scattering_type,str(ac.count), str("%10.2f"%ac.occupancy_sum).strip())) atom_counts_str = " ".join(atom_counts_strs) b_isos = xrs.extract_u_iso_or_u_equiv() n_aniso = xrs.use_u_aniso().count(True) n_not_positive_definite = xrs.is_positive_definite_u().count(False) b_mean = format_value("%-6.1f",adptbx.u_as_b(flex.mean(b_isos))) b_min = format_value("%-6.1f",adptbx.u_as_b(flex.min(b_isos))) b_max = format_value("%-6.1f",adptbx.u_as_b(flex.max(b_isos))) n_atoms = format_value("%-8d",xrs.scatterers().size()).strip() n_npd = format_value("%-8s",n_not_positive_definite).strip() occ = xrs.scatterers().extract_occupancies() o_mean = format_value("%-6.2f",flex.mean(occ)).strip() o_min = format_value("%-6.2f",flex.min(occ)).strip() o_max = format_value("%-6.2f",flex.max(occ)).strip() tmp_result = group_args( n_atoms = n_atoms, atom_counts_str = atom_counts_str, b_min = b_min, b_max = b_max, b_mean = b_mean, o_min = o_min, o_max = o_max, o_mean = o_mean, n_aniso = n_aniso, n_npd = n_npd) setattr(result,key,tmp_result) return result
def test_4(): symmetry = crystal.symmetry(unit_cell = (15.67, 25.37, 35.68, 90, 90, 90), space_group_symbol = "P 21 21 21") structure = xray.structure(crystal_symmetry = symmetry) ma = structure.structure_factors(d_min = 1.5, anomalous_flag = False).f_calc() mi = ma.indices() # ================================================================= TEST-1 alpha = flex.double(mi.size()) beta = flex.double(mi.size()) d_obs = flex.double(mi.size()) d_calc = flex.double(mi.size()) # define test set reflections flags=flex.int(beta.size(), 0) k=0 for i in xrange(flags.size()): k=k+1 if (k !=10): flags[i]=0 else: k=0 flags[i]=1 for i in range(1,mi.size()+1): d_obs [i-1] = i*1.5 d_calc[i-1] = i*1.0 beta [i-1] = i*500.0 alpha [i-1] = float(i) / float(i + 1) obj = max_lik.fom_and_phase_error( f_obs = d_obs, f_model = d_calc, alpha = alpha, beta = beta, epsilons = ma.epsilons().data().as_double(), centric_flags = ma.centric_flags().data()) per = obj.phase_error() fom = obj.fom() assert approx_equal(flex.max(per) , 89.9325000127 , 1.e-4) assert approx_equal(flex.min(per) , 5.37565067746e-05 , 1.e-4) assert approx_equal(flex.mean(per), 20.7942460698 , 1.e-4) assert approx_equal(flex.max(fom) , 0.999999402705 , 1.e-4) assert approx_equal(flex.min(fom) , 0.000749999859375 , 1.e-4) assert approx_equal(flex.mean(fom), 0.858269037582 , 1.e-4)
def __init__(self, unmerged_intensities, batches): self.unmerged_intensities = unmerged_intensities self.batches = batches self.minb = flex.min(self.batches.data()) self.maxb = flex.max(self.batches.data()) n_scale_factors = self.maxb - self.minb + 1 self.x = flex.double(n_scale_factors, 1) scitbx.lbfgs.run(target_evaluator=self)
def __init__(self, unmerged_intensities, batches): self.unmerged_intensities = unmerged_intensities self.batches = batches self.minb = flex.min(self.batches.data()) self.maxb = flex.max(self.batches.data()) n_scale_factors = self.maxb-self.minb + 1 self.x = flex.double(n_scale_factors, 1) scitbx.lbfgs.run(target_evaluator=self)
def functional(self, x): if (0): print "functional(): x =", list(x) if (flex.min(x[:3]) < 1): print "FunctionalException: small length" raise scitbx.minimizers.FunctionalException if (flex.min(x[3:]) < 50): print "FunctionalException: small angle" raise scitbx.minimizers.FunctionalException try: result = residual( self.two_thetas_obs, self.miller_indices, self.wavelength, unit_cell=uctbx.unit_cell(iter(x))) except KeyboardInterrupt: raise except Exception, e: print "FunctionalException:", str(e) raise scitbx.minimizers.FunctionalException
def __call__(self, xray_structure, u_iso_refinable_params, dp, n_parameters, verbose=0): omptbx.env.num_threads = libtbx.introspection.number_of_processors() result = xray.fast_gradients( unit_cell=xray_structure.unit_cell(), scatterers=xray_structure.scatterers(), scattering_type_registry=xray_structure.scattering_type_registry(), u_base=self.u_base(), wing_cutoff=self.wing_cutoff(), exp_table_one_over_step_size=self.exp_table_one_over_step_size(), tolerance_positive_definite=1.e-5) if (0 or verbose): print("u_base:", result.u_base()) print("u_extra:", result.u_extra()) gradient_map = self.ft_dp(dp, u_extra=result.u_extra()) if (not gradient_map.anomalous_flag()): gradient_map = gradient_map.real_map() else: gradient_map = gradient_map.complex_map() assert not gradient_map.is_padded() if (0 or verbose): print("grid:", gradient_map.focus()) print("ft_dt_map real: %.4g %.4g" % (flex.min(flex.real(gradient_map)), flex.max(flex.real(gradient_map)))) print("ft_dt_map imag: %.4g %.4g" % (flex.min(flex.imag(gradient_map)), flex.max(flex.imag(gradient_map)))) print() result.sampling( scatterers=xray_structure.scatterers(), u_iso_refinable_params=u_iso_refinable_params, scattering_type_registry=xray_structure.scattering_type_registry(), site_symmetry_table=xray_structure.site_symmetry_table(), ft_d_target_d_f_calc=gradient_map, n_parameters=n_parameters, sampled_density_must_be_positive=False) if (0 or verbose): print("max_sampling_box_edges:", result.max_sampling_box_edges()) print("exp_table_size:", result.exp_table_size()) print() return result
def test_4(): symmetry = crystal.symmetry(unit_cell = (15.67, 25.37, 35.68, 90, 90, 90), space_group_symbol = "P 21 21 21") structure = xray.structure(crystal_symmetry = symmetry) ma = structure.structure_factors(d_min = 1.5, anomalous_flag = False).f_calc() mi = ma.indices() # ================================================================= TEST-1 alpha = flex.double(mi.size()) beta = flex.double(mi.size()) d_obs = flex.double(mi.size()) d_calc = flex.double(mi.size()) # define test set reflections flags=flex.int(beta.size(), 0) k=0 for i in range(flags.size()): k=k+1 if (k !=10): flags[i]=0 else: k=0 flags[i]=1 for i in range(1,mi.size()+1): d_obs [i-1] = i*1.5 d_calc[i-1] = i*1.0 beta [i-1] = i*500.0 alpha [i-1] = float(i) / float(i + 1) obj = max_lik.fom_and_phase_error( f_obs = d_obs, f_model = d_calc, alpha = alpha, beta = beta, epsilons = ma.epsilons().data().as_double(), centric_flags = ma.centric_flags().data()) per = obj.phase_error() fom = obj.fom() assert approx_equal(flex.max(per) , 89.9325000127 , 1.e-4) assert approx_equal(flex.min(per) , 5.37565067746e-05 , 1.e-4) assert approx_equal(flex.mean(per), 20.7942460698 , 1.e-4) assert approx_equal(flex.max(fom) , 0.999999402705 , 1.e-4) assert approx_equal(flex.min(fom) , 0.000749999859375 , 1.e-4) assert approx_equal(flex.mean(fom), 0.858269037582 , 1.e-4)
def exercise_2(): symmetry = crystal.symmetry( unit_cell=(5.67, 10.37, 10.37, 90, 135.49, 90), space_group_symbol="C2") structure = xray.structure(crystal_symmetry=symmetry) atmrad = flex.double() xyzf = flex.vec3_double() for k in xrange(100): scatterer = xray.scatterer( site = ((1.+k*abs(math.sin(k)))/1000.0, (1.+k*abs(math.cos(k)))/1000.0, (1.+ k)/1000.0), scattering_type = "C") structure.add_scatterer(scatterer) atmrad.append(van_der_waals_radii.vdw.table[scatterer.element_symbol()]) xyzf.append(scatterer.site) miller_set = miller.build_set( crystal_symmetry=structure, d_min=1.0, anomalous_flag=False) step = 0.5 crystal_gridding = maptbx.crystal_gridding( unit_cell=structure.unit_cell(), step=step) nxyz = crystal_gridding.n_real() shrink_truncation_radius = 1.0 solvent_radius = 1.0 m1 = around_atoms( structure.unit_cell(), structure.space_group().order_z(), structure.sites_frac(), atmrad, nxyz, solvent_radius, shrink_truncation_radius) assert m1.solvent_radius == 1 assert m1.shrink_truncation_radius == 1 assert flex.max(m1.data) == 1 assert flex.min(m1.data) == 0 assert m1.data.size() == m1.data.count(1) + m1.data.count(0) m2 = mmtbx.masks.bulk_solvent( xray_structure=structure, gridding_n_real=nxyz, ignore_zero_occupancy_atoms = False, solvent_radius=solvent_radius, shrink_truncation_radius=shrink_truncation_radius) assert m2.data.all_eq(m1.data) m3 = mmtbx.masks.bulk_solvent( xray_structure=structure, grid_step=step, ignore_zero_occupancy_atoms = False, solvent_radius=solvent_radius, shrink_truncation_radius=shrink_truncation_radius) assert m3.data.all_eq(m1.data) f_mask2 = m2.structure_factors(miller_set=miller_set) f_mask3 = m3.structure_factors(miller_set=miller_set) assert approx_equal(f_mask2.data(), f_mask3.data()) assert approx_equal(flex.sum(flex.abs(f_mask3.data())), 1095.17999134)
def __call__(self, xray_structure, u_iso_refinable_params, dp, n_parameters, verbose=0): omptbx.env.num_threads = libtbx.introspection.number_of_processors() result = xray.fast_gradients( unit_cell=xray_structure.unit_cell(), scatterers=xray_structure.scatterers(), scattering_type_registry=xray_structure.scattering_type_registry(), u_base=self.u_base(), wing_cutoff=self.wing_cutoff(), exp_table_one_over_step_size=self.exp_table_one_over_step_size(), tolerance_positive_definite=1.e-5) if (0 or verbose): print "u_base:", result.u_base() print "u_extra:", result.u_extra() gradient_map = self.ft_dp(dp, u_extra=result.u_extra()) if (not gradient_map.anomalous_flag()): gradient_map = gradient_map.real_map() else: gradient_map = gradient_map.complex_map() assert not gradient_map.is_padded() if (0 or verbose): print "grid:", gradient_map.focus() print "ft_dt_map real: %.4g %.4g" % ( flex.min(flex.real(gradient_map)), flex.max(flex.real(gradient_map))) print "ft_dt_map imag: %.4g %.4g" % ( flex.min(flex.imag(gradient_map)), flex.max(flex.imag(gradient_map))) print result.sampling( scatterers=xray_structure.scatterers(), u_iso_refinable_params=u_iso_refinable_params, scattering_type_registry=xray_structure.scattering_type_registry(), site_symmetry_table=xray_structure.site_symmetry_table(), ft_d_target_d_f_calc=gradient_map, n_parameters=n_parameters, sampled_density_must_be_positive=False) if (0 or verbose): print "max_sampling_box_edges:", result.max_sampling_box_edges() print "exp_table_size:", result.exp_table_size() print return result
def compute(miller_array, step_scale=0.0005): miller_array.show_comprehensive_summary(prefix=" ") step = miller_array.d_min() * step_scale # ma_p1 = miller_array.expand_to_p1() # n_h = {} n_k = {} n_l = {} indices = ma_p1.indices() for ind in indices: h, k, l = ind n_h.setdefault(h, flex.int()).append(1) n_k.setdefault(k, flex.int()).append(1) n_l.setdefault(l, flex.int()).append(1) def count(d): for k in d.keys(): d[k] = d[k].size() return d n_h = count(n_h) n_k = count(n_k) n_l = count(n_l) # resolutions along axes a, b, c = miller_array.unit_cell().parameters()[:3] x, rho_x = one_d_image_along_axis(n=n_h, step=step, uc_length=a) y, rho_y = one_d_image_along_axis(n=n_k, step=step, uc_length=b) z, rho_z = one_d_image_along_axis(n=n_l, step=step, uc_length=c) # 2nd derivatives r2x = second_derivatives(rho=rho_x, delta=step) r2y = second_derivatives(rho=rho_y, delta=step) r2z = second_derivatives(rho=rho_z, delta=step) # effective resolution along axes d_eff_a = compute_d_eff(r=x, rho_2nd=r2x) d_eff_b = compute_d_eff(r=y, rho_2nd=r2y) d_eff_c = compute_d_eff(r=z, rho_2nd=r2z) print(" Effective resolution along axes a,b,c: %6.3f %6.3f %6.3f" % (d_eff_a, d_eff_b, d_eff_c)) # all directions l = 0.8 * min(d_eff_a / 2.5, d_eff_b / 2.5, d_eff_c / 2.5) r = 1.2 * max(d_eff_a / 2.5, d_eff_b / 2.5, d_eff_c / 2.5) us = regular_grid_on_unit_sphere.rosca(m=9, hemisphere=True) d_effs = flex.double() o = maptbx.ft_analytical_1d_point_scatterer_at_origin(N=100000) for i, u in enumerate(us): o.compute(miller_indices=indices, step=step, left=l, right=r, u_frac=miller_array.unit_cell().fractionalize(u)) dist, rho_ = o.distances(), o.rho() rho2 = second_derivatives(rho=rho_, delta=step) d_eff = compute_d_eff(r=dist, rho_2nd=rho2) d_effs.append(d_eff) print(" Effective resolution (min,max): %8.3f%8.3f" % (flex.min(d_effs), flex.max(d_effs)))
def test_3(): symmetry = crystal.symmetry(unit_cell = (15.67, 25.37, 35.68, 90, 90, 90), space_group_symbol = "P 21 21 21") structure = xray.structure(crystal_symmetry = symmetry) mi = structure.structure_factors(d_min = 1.5, anomalous_flag = False).f_calc().indices() # ================================================================= TEST-1 alpha = flex.double(mi.size()) beta = flex.double(mi.size()) d_obs = flex.double(mi.size()) d_calc = flex.double(mi.size()) for i in range(1,mi.size()+1): d_obs [i-1] = i*1.0 d_calc[i-1] = i*1.0 beta [i-1] = i*500.0 alpha [i-1] = float(i) / float(i + 1) obj = max_lik.f_star_w_star_mu_nu(f_obs = d_obs, f_model = d_calc, alpha = alpha, beta = beta, space_group = symmetry.space_group(), miller_indices = mi) f_star = obj.f_star() w_star = obj.w_star() mu = obj.mu() nu = obj.nu() nzero = obj.number_of_f_star_zero() assert approx_equal(flex.max(f_star) , 2505.77677201 , 1.e-4) assert approx_equal(flex.min(f_star) , 0.0 , 1.e-4) assert approx_equal(flex.mean(f_star), 1085.99060715 , 1.e-4) assert approx_equal(flex.max(w_star) , 1.0 , 1.e-4) assert approx_equal(flex.min(w_star) , 0.0 , 1.e-4) assert approx_equal(flex.mean(w_star), 0.01782658613 , 1.e-4) assert approx_equal(flex.max(mu) , 2.23810354633 , 1.e-4) assert approx_equal(flex.min(mu) , 0.0 , 1.e-4) assert approx_equal(flex.mean(mu) , 1.20159615933 , 1.e-4) assert approx_equal(flex.max(nu) , 0.999107484116, 1.e-4) assert approx_equal(flex.min(nu) , 0.0 , 1.e-4) assert approx_equal(flex.mean(nu) , 0.745699513719, 1.e-4) assert approx_equal(nzero , 501 )
def compute(miller_array, step_scale=0.0005): miller_array.show_comprehensive_summary(prefix=" ") step = miller_array.d_min()*step_scale # ma_p1 = miller_array.expand_to_p1() # n_h = {} n_k = {} n_l = {} indices = ma_p1.indices() for ind in indices: h,k,l = ind n_h.setdefault(h, flex.int()).append(1) n_k.setdefault(k, flex.int()).append(1) n_l.setdefault(l, flex.int()).append(1) def count(d): for k in d.keys(): d[k] = d[k].size() return d n_h = count(n_h) n_k = count(n_k) n_l = count(n_l) # resolutions along axes a,b,c = miller_array.unit_cell().parameters()[:3] x, rho_x = one_d_image_along_axis(n=n_h, step=step, uc_length=a) y, rho_y = one_d_image_along_axis(n=n_k, step=step, uc_length=b) z, rho_z = one_d_image_along_axis(n=n_l, step=step, uc_length=c) # 2nd derivatives r2x = second_derivatives(rho=rho_x, delta=step) r2y = second_derivatives(rho=rho_y, delta=step) r2z = second_derivatives(rho=rho_z, delta=step) # effective resolution along axes d_eff_a = compute_d_eff(r=x, rho_2nd=r2x) d_eff_b = compute_d_eff(r=y, rho_2nd=r2y) d_eff_c = compute_d_eff(r=z, rho_2nd=r2z) print " Effective resolution along axes a,b,c: %6.3f %6.3f %6.3f"%( d_eff_a, d_eff_b, d_eff_c) # all directions l = 0.8 * min(d_eff_a/2.5, d_eff_b/2.5, d_eff_c/2.5) r = 1.2 * max(d_eff_a/2.5, d_eff_b/2.5, d_eff_c/2.5) us = regular_grid_on_unit_sphere.rosca(m=9, hemisphere=True) d_effs = flex.double() o = maptbx.ft_analytical_1d_point_scatterer_at_origin(N=100000) for i, u in enumerate(us): o.compute( miller_indices=indices, step=step, left=l, right=r, u_frac=miller_array.unit_cell().fractionalize(u)) dist, rho_ = o.distances(), o.rho() rho2 = second_derivatives(rho=rho_, delta=step) d_eff = compute_d_eff(r=dist, rho_2nd=rho2) d_effs.append(d_eff) print " Effective resolution (min,max): %8.3f%8.3f"%( flex.min(d_effs), flex.max(d_effs))
def functional(self, x): if (0): print "functional(): x =", list(x) if (flex.min(x[:3]) < 1): print "FunctionalException: small length" raise scitbx.minimizers.FunctionalException if (flex.min(x[3:]) < 50): print "FunctionalException: small angle" raise scitbx.minimizers.FunctionalException try: result = residual(self.two_thetas_obs, self.miller_indices, self.wavelength, unit_cell=uctbx.unit_cell(iter(x))) except KeyboardInterrupt: raise except Exception, e: print "FunctionalException:", str(e) raise scitbx.minimizers.FunctionalException
def resolution_fit(d_star_sq, y_obs, model, limit, sel=None): """Estimate a resolution limit based on the input merging statistics The function defined by `model` will be fit to the input `d_star_sq` and `y_obs`. The estimated resolution limit is chosen as the `d_star_sq` value at which the fitted function equals `limit`. Args: d_star_sq (scitbx.array_family.flex.double): The high resolution limits of the resolution bins in units 1/d*2 y_obs (scitbx.array_family.flex.double): The statistic against which to fit the function `model` model: The function to fit against `y_obs`. Must be callable, taking as input x (d_star_sq) and y (the metric to be fitted) values, returning the fitted y(x) values. limit (float): The resolution limit criterion. sel (scitbx.array_family.flex.bool): An optional selection to apply to the `d_star_sq` and `y_obs` values. Returns: The estimated resolution limit in units of Å^-1 Raises: RuntimeError: Raised if no `y_obs` values remain after application of the selection `sel` """ if not sel: sel = flex.bool(len(d_star_sq), True) sel &= y_obs > 0 y_obs = y_obs.select(sel) d_star_sq = d_star_sq.select(sel) if not len(y_obs): raise RuntimeError("No reflections left for fitting") y_fit = model(d_star_sq, y_obs, 6) logger.debug( tabulate( [("d*2", "d", "obs", "fit")] + [ (ds2, uctbx.d_star_sq_as_d(ds2), yo, yf) for ds2, yo, yf in zip(d_star_sq, y_obs, y_fit) ], headers="firstrow", ) ) if flex.min(y_obs) > limit: d_min = 1.0 / math.sqrt(flex.max(d_star_sq)) else: try: d_min = 1.0 / math.sqrt(interpolate_value(d_star_sq, y_fit, limit)) except RuntimeError as e: logger.debug(f"Error interpolating value: {e}") d_min = None return ResolutionResult(d_star_sq, y_obs, y_fit, d_min)
def exercise_with_pdb(verbose): if (not libtbx.env.has_module(name="mmtbx")): print("Skipping exercise_with_pdb():", \ "mmtbx.monomer_library.pdb_interpretation not available") return if (libtbx.env.find_in_repositories(relative_path="chem_data") is None): print( "Skipping exercise_with_pdb(): chem_data directory not available") return if (verbose): out = sys.stdout else: out = StringIO() with open("tmp_cctbx_geometry_restraints.pdb", "w") as f: f.write(enk_pdb) pdb_interpretation_params = pdb_interpretation.master_params.extract() pdb_interpretation_params.sort_atoms = False processed_pdb_file = pdb_interpretation.run( args=["tmp_cctbx_geometry_restraints.pdb"], strict_conflict_handling=False, params=pdb_interpretation_params, log=out, ) geo = processed_pdb_file.geometry_restraints_manager() site_labels = processed_pdb_file.xray_structure().scatterers() \ .extract_labels() # assert approx_equal(flex.min(geo.nonbonded_model_distances()), 0.4777342) # geo._sites_cart_used_for_pair_proxies = None # sel0 = geo.simple_edge_list() assert len(sel0) == 46 assert sel0[:4] == [(0, 1), (0, 8), (0, 11), (1, 2)] assert sel0[-4:] == [(42, 43), (42, 44), (45, 46), (45, 47)] geo.bond_params_table[13][14].slack = 0.1 geo.bond_params_table[28][30].slack = 0.3 sel = geo.simple_edge_list() assert sorted(set(sel0) - set(sel)) == [(13, 14), (28, 30)] sel = geo.simple_edge_list(omit_slack_greater_than=0.2) assert sorted(set(sel0) - set(sel)) == [(28, 30)] # d = geo.discard_symmetry(new_unit_cell=(10, 10, 10, 90, 90, 90)) assert d.site_symmetry_table.special_position_indices().size() == 0 # clusters = geo.rigid_clusters_due_to_dihedrals_and_planes( constrain_dihedrals_with_sigma_less_than=10) assert sorted([tuple(sorted(c)) for c in clusters]) == [(0, 8, 10, 15), (0, 8, 12, 15), (1, 2, 3, 4, 5, 6, 7, 9), (5, 6, 7, 9), (12, 13, 14, 19), (12, 13, 16, 19), (16, 17, 18, 29), (16, 17, 20, 29), (20, 28, 30, 37), (20, 28, 31, 37), (21, 22, 23, 24, 25, 26, 27)]
def miller_array_as_phases_phs(self, out, scale_amplitudes=True, phases=None, phases_deg=None, figures_of_merit=None): """http://www.sdsc.edu/CCMS/Packages/XTALVIEW/xtalviewfaq.html""" if (phases is not None): assert phases_deg is False or phases_deg is True if (self.is_complex_array()): amplitudes = self.amplitudes().data() else: amplitudes = self.data() if (scale_amplitudes): amplitudes_max = flex.max(amplitudes) if (amplitudes_max > 0): amplitudes = (9999.99 / amplitudes_max) * amplitudes assert len(" %7.2f" % flex.min(amplitudes)) == 8 assert len(" %7.2f" % flex.max(amplitudes)) == 8 if (phases is None): phases = self.phases(deg=True).data() else: if (hasattr(phases, "data")): phases = phases.data() if (not phases_deg): phases = phases * (180 / math.pi) assert len(" %7.2f" % flex.min(phases)) == 8 assert len(" %7.2f" % flex.max(phases)) == 8 if (figures_of_merit is None): for h, a, p in zip(self.indices(), amplitudes, phases): print("%4d%4d%4d" % h + " %7.2f" % a + " %7.2f" % 1 + " %7.2f" % p, file=out) else: if (hasattr(figures_of_merit, "data")): assert figures_of_merit.indices().all_eq(self.indices()) figures_of_merit = figures_of_merit.data() assert len(" %7.2f" % flex.min(figures_of_merit)) == 8 assert len(" %7.2f" % flex.max(figures_of_merit)) == 8 for h, a, p, f in zip(self.indices(), amplitudes, phases, figures_of_merit): print("%4d%4d%4d" % h + " %7.2f" % a + " %7.2f" % f + " %7.2f" % p, file=out)
def _show_each (edges) : for edge, ref_edge, label in zip(edges, ref_edges, labels) : h = flex.histogram(edge, n_slots=n_slots) smin, smax = flex.min(edge), flex.max(edge) stats = flex.mean_and_variance(edge) print >> out, " %s edge" % label print >> out, " range: %6.2f - %.2f" % (smin, smax) print >> out, " mean: %6.2f +/- %6.2f on N = %d" % ( stats.mean(), stats.unweighted_sample_standard_deviation(), edge.size()) print >> out, " reference: %6.2f" % ref_edge h.show(f=out, prefix=" ", format_cutoffs="%6.2f") print >> out, ""
def __init__( self, intensities, params, batches=None, scales=None, dose=None, report_dir=None, experiments=None, ): self.params = params if params.d_min or params.d_max: intensities = intensities.resolution_filter(d_min=params.d_min, d_max=params.d_max) if batches: batches = batches.resolution_filter(d_min=params.d_min, d_max=params.d_max) if scales: scales = scales.resolution_filter(d_min=params.d_min, d_max=params.d_max) self.intensities = intensities self.experiments = experiments self.batches = batches self.scales = scales self.dose = dose self.report_dir = report_dir self._xanalysis = None assert self.intensities is not None # assert self.batches is not None if self.batches is not None and len(self.params.batch) == 0: separate = separate_unmerged(self.intensities, self.batches) scope = libtbx.phil.parse(batch_phil_scope) for i, batches in separate.batches.items(): batch_params = scope.extract().batch[0] batch_params.id = i batch_params.range = ( flex.min(batches.data()), flex.max(batches.data()), ) self.params.batch.append(batch_params) if self.params.anomalous: self.intensities = self.intensities.as_anomalous_array() if self.batches is not None: self.batches = self.batches.as_anomalous_array() self.intensities.setup_binner(n_bins=self.params.resolution_bins) self.merged_intensities = self.intensities.merge_equivalents().array()
def show_refinement_update(fmodels, selection, da_sel_refinable, prefix): fmt1 = "%s Rwork= %8.6f Rfree= %8.6f Number of: non-DA= %d DA= %d all= %d" print fmt1%(prefix, fmodels.fmodel_xray().r_work(), fmodels.fmodel_xray().r_free(), selection.count(False),selection.count(True), fmodels.fmodel_xray().xray_structure.scatterers().size()) occ = fmodels.fmodel_xray().xray_structure.scatterers().extract_occupancies() occ_da = occ.select(selection) if(occ_da.size()>0): occ_ma = occ.select(~selection) print " non-da: occ(min,max,mean)= %6.3f %6.3f %6.3f"%( flex.min(occ_ma),flex.max(occ_ma),flex.mean(occ_ma)) print " da: occ(min,max,mean)= %6.3f %6.3f %6.3f"%( flex.min(occ_da),flex.max(occ_da),flex.mean(occ_da)) b = fmodels.fmodel_xray().xray_structure.extract_u_iso_or_u_equiv()*\ adptbx.u_as_b(1.) b_da = b.select(selection) b_ma = b.select(~selection) print " non-da: ADP(min,max,mean)= %7.2f %7.2f %7.2f"%( flex.min(b_ma),flex.max(b_ma),flex.mean(b_ma)) print " da: ADP(min,max,mean)= %7.2f %7.2f %7.2f"%( flex.min(b_da),flex.max(b_da),flex.mean(b_da)) print "da_sel_refinable:", da_sel_refinable.size(), da_sel_refinable.count(True)
def exercise_with_pdb(verbose): if (not libtbx.env.has_module(name="mmtbx")): print "Skipping exercise_with_pdb():", \ "mmtbx.monomer_library.pdb_interpretation not available" return if (libtbx.env.find_in_repositories(relative_path="chem_data") is None): print "Skipping exercise_with_pdb(): chem_data directory not available" return if (verbose): out = sys.stdout else: out = StringIO() open("tmp_cctbx_geometry_restraints.pdb", "w").write(enk_pdb) pdb_interpretation_params = pdb_interpretation.master_params.extract() pdb_interpretation_params.sort_atoms=False processed_pdb_file = pdb_interpretation.run( args=["tmp_cctbx_geometry_restraints.pdb"], strict_conflict_handling=False, params=pdb_interpretation_params, log=out,) geo = processed_pdb_file.geometry_restraints_manager() site_labels = processed_pdb_file.xray_structure().scatterers() \ .extract_labels() # assert approx_equal(flex.min(geo.nonbonded_model_distances()), 0.4777342) # geo._sites_cart_used_for_pair_proxies = None # sel0 = geo.simple_edge_list() assert len(sel0) == 46 assert sel0[:4] == [(0, 1), (0, 8), (0, 11), (1, 2)] assert sel0[-4:] == [(42, 43), (42, 44), (45, 46), (45, 47)] geo.bond_params_table[13][14].slack = 0.1 geo.bond_params_table[28][30].slack = 0.3 sel = geo.simple_edge_list() assert sorted(set(sel0) - set(sel)) == [(13, 14), (28, 30)] sel = geo.simple_edge_list(omit_slack_greater_than=0.2) assert sorted(set(sel0) - set(sel)) == [(28, 30)] # d = geo.discard_symmetry(new_unit_cell=(10,10,10,90,90,90)) assert d.site_symmetry_table.special_position_indices().size()==0 # clusters = geo.rigid_clusters_due_to_dihedrals_and_planes( constrain_dihedrals_with_sigma_less_than=10) assert sorted([tuple(sorted(c)) for c in clusters]) == [ (0, 8, 10, 15), (0, 8, 12, 15), (1, 2, 3, 4, 5, 6, 7, 9), (5, 6, 7, 9), (12, 13, 14, 19), (12, 13, 16, 19), (16, 17, 18, 29), (16, 17, 20, 29), (20, 28, 30, 37), (20, 28, 31, 37), (21, 22, 23, 24, 25, 26, 27)]
def minimize_kbu(self, n_cycles=10): #print "minimize_kbu start r:", self.kbu.r_factor() for use_curvatures in [False, True]*n_cycles: #print " minimize_kbu r:", self.kbu.r_factor() start_r = self.kbu.r_factor() save_k_sols = self.kbu.k_sols() save_b_sols = self.kbu.b_sols() save_b_cart = self.kbu.b_cart() #self.set_use_scale(value = random.choice([True, False])) self.set_use_scale(value = True) m = self.minimize_kb_once(use_curvatures=use_curvatures) r = self.kbu.r_factor() if(r>start_r and r>1.e-2 and (flex.min(self.kbu.k_sols())<0 or flex.max(self.kbu.k_sols())>1 or flex.min(self.kbu.b_sols())<0 or flex.max(self.kbu.k_sols())>100.)): self.kbu.update(k_sols = save_k_sols, b_sols = save_b_sols) # assert m.minimizer.n_calls == m.minimizer.nfun() m = self.minimize_u_once() # assert m.minimizer.n_calls == m.minimizer.nfun() r = self.kbu.r_factor() bc = list(flex.abs(flex.double(self.kbu.b_cart()))) if(r>start_r and r>1.e-2 and max(bc)>100): self.kbu.update(b_cart = save_b_cart) break
def update(O, miller_index_i_seqs): from cctbx.array_family import flex if (O.use_symmetry): isel = O.i_calc.asu_iselection.select(miller_index_i_seqs) else: isel = miller_index_i_seqs previously_zero = O.counts.increment_and_track_up_from_zero( iselection=isel) O.new_0 = O.currently_zero - previously_zero O.completeness_history.append(1-O.new_0/O.n_indices) O.min_count_history.append(flex.min(O.counts)) assert O.new_0 >= 0 if (O.new_0 == 0 and O.currently_zero != 0): print "Complete with %d images." % (len(O.completeness_history)-1) print O.currently_zero = O.new_0
def exercise_icosahedron(max_level=2, verbose=0): for level in xrange(0,max_level+1): if (0 or verbose): print "level:", level icosahedron = scitbx.math.icosahedron(level=level) try: distance_cutoff = icosahedron.next_neighbors_distance()*(1+1.e-3) estimated_distance_cutoff = False except RuntimeError, e: assert str(e) == "next_neighbors_distance not known." distance_cutoff = 0.4/(2**(level-1)) estimated_distance_cutoff = True asu_mappings = crystal.direct_space_asu.non_crystallographic_asu_mappings( sites_cart=icosahedron.sites) pair_asu_table = crystal.pair_asu_table(asu_mappings=asu_mappings) pair_asu_table.add_all_pairs(distance_cutoff=distance_cutoff) if (0 or verbose): ps = pair_asu_table.show_distances(sites_cart=icosahedron.sites) \ .distances_info print "level", level, "min", flex.min(ps.distances) print " ", " ", "max", flex.max(ps.distances) assert ps.pair_counts.all_eq(pair_asu_table.pair_counts()) if (level == 0): for d in ps.distances: assert approx_equal(d, 1.0514622242382672) elif (level < 2): s = StringIO() ps = pair_asu_table.show_distances(sites_cart=icosahedron.sites, out=s) \ .distances_info assert ps.pair_counts.all_eq(pair_asu_table.pair_counts()) assert len(s.getvalue().splitlines()) == [72,320][level] del s if (level == 0): assert pair_asu_table.pair_counts().all_eq(5) else: assert pair_asu_table.pair_counts().all_eq(3) del pair_asu_table max_distance = crystal.neighbors_fast_pair_generator( asu_mappings=asu_mappings, distance_cutoff=distance_cutoff).max_distance_sq()**.5 if (0 or verbose): print "max_distance:", max_distance if (not estimated_distance_cutoff): assert approx_equal(max_distance, icosahedron.next_neighbors_distance()) assert approx_equal(max_distance/icosahedron.next_neighbors_distance(),1)
def as_miller_arrays(self, crystal_symmetry=None, force_symmetry=False, merge_equivalents=True, base_array_info=None, include_unmerged_data=False, ): assert not include_unmerged_data, "Unmerged data not supported in MTZ" other_symmetry = crystal_symmetry if (base_array_info is None): base_array_info = miller.array_info(source_type="ccp4_mtz") result = [] for crystal in self.crystals(): try : unit_cell = crystal.unit_cell() except ValueError, e : raise Sorry(str(e)) crystal_symmetry_from_file = cctbx.crystal.symmetry( unit_cell=unit_cell, space_group_info=self.space_group_info(), raise_sorry_if_incompatible_unit_cell=True) crystal_symmetry = crystal_symmetry_from_file.join_symmetry( other_symmetry=other_symmetry, force=force_symmetry) for dataset in crystal.datasets(): base_dataset_info = base_array_info.customized_copy( wavelength=dataset.wavelength()) column_groups = self.group_columns( crystal_symmetry_from_file=crystal_symmetry_from_file, crystal_symmetry=crystal_symmetry, base_array_info=base_dataset_info, dataset=dataset) for column_group in column_groups: if (merge_equivalents and isinstance(column_group.data(), flex.double) and isinstance(column_group.sigmas(), flex.double) and column_group.sigmas().size() != 0 and flex.min(column_group.sigmas()) > 0): merged_column_group = column_group.merge_equivalents().array() if (merged_column_group.indices().size() != column_group.indices().size()): merged_column_group.set_info( column_group.info().customized_copy(merged=True)) column_group = merged_column_group result.append(column_group)
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 resolution_merged_isigma(self, limit = None, log = None): '''Compute a resolution limit where either Mn(I/sigma) = 1.0 (limit if set) or the full extent of the data.''' if limit is None: limit = self._params.misigma misigma_s = flex.double( [b.i_over_sigma_mean for b in self._merging_statistics.bins]).reversed() s_s = flex.double( [1/b.d_min**2 for b in self._merging_statistics.bins]).reversed() sel = misigma_s > 0 misigma_s = misigma_s.select(sel) s_s = s_s.select(sel) if flex.min(misigma_s) > limit: return 1.0 / math.sqrt(flex.max(s_s)) misigma_f = log_fit(s_s, misigma_s, 6) if log: fout = open(log, 'w') for j, s in enumerate(s_s): d = 1.0 / math.sqrt(s) o = misigma_s[j] m = misigma_f[j] fout.write('%f %f %f %f\n' % (s, d, o, m)) fout.close() try: r_misigma = 1.0 / math.sqrt( interpolate_value(s_s, misigma_f, limit)) except: r_misigma = 1.0 / math.sqrt(flex.max(s_s)) if self._params.plot: plot = resolution_plot(ylabel='Merged I/sigma') plot.plot(s_s, misigma_f, label='fit') plot.plot(s_s, misigma_s, label='Merged I/sigma') plot.plot_resolution_limit(r_misigma) plot.savefig('misigma.png') return r_misigma
def resolution_completeness(self, limit = None, log = None): '''Compute a resolution limit where completeness < 0.5 (limit if set) or the full extent of the data. N.B. this completeness is with respect to the *maximum* completeness in a shell, to reflect triclinic cases.''' if limit is None: limit = self._params.completeness comp_s = flex.double( [b.completeness for b in self._merging_statistics.bins]).reversed() s_s = flex.double( [1/b.d_min**2 for b in self._merging_statistics.bins]).reversed() if flex.min(comp_s) > limit: return 1.0 / math.sqrt(flex.max(s_s)) comp_f = fit(s_s, comp_s, 6) rlimit = limit * max(comp_s) if log: fout = open(log, 'w') for j, s in enumerate(s_s): d = 1.0 / math.sqrt(s) o = comp_s[j] m = comp_f[j] fout.write('%f %f %f %f\n' % (s, d, o, m)) fout.close() try: r_comp = 1.0 / math.sqrt( interpolate_value(s_s, comp_f, rlimit)) except Exception: r_comp = 1.0 / math.sqrt(flex.max(s_s)) if self._params.plot: plot = resolution_plot(ylabel='Completeness') plot.plot(s_s, comp_f, label='fit') plot.plot(s_s, comp_s, label='Completeness') plot.plot_resolution_limit(r_comp) plot.savefig('completeness.png') return r_comp