def get_indexing_offset_correlation_coefficients( reflections, crystal, grid_search_scope, d_min=None, d_max=None, map_to_asu=False ): from copy import deepcopy from dials.array_family import flex space_group = crystal.get_space_group() unit_cell = crystal.get_unit_cell() from cctbx.crystal import symmetry as crystal_symmetry cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol()) from cctbx.miller import set as miller_set data = reflections["intensity.sum.value"] / flex.sqrt(reflections["intensity.sum.variance"]) ccs = flex.double() offsets = flex.vec3_int() nref = flex.size_t() original_miller_indices = reflections["miller_index"] ms = miller_set(cs, original_miller_indices) ms = ms.array(data) if d_min is not None or d_max is not None: ms = ms.resolution_filter(d_min=d_min, d_max=d_max) if map_to_asu: ms = ms.map_to_asu() g = grid_search_scope for h in range(-g, g + 1): for k in range(-g, g + 1): for l in range(-g, g + 1): for smx in ["-x,-y,-z"]: # reindexed = deepcopy(reflections) # hkl offset doubled as equivalent of h0 + 1, hI - 1 miller_indices = offset_miller_indices(ms.indices(), (2 * h, 2 * k, 2 * l)) reindexed_miller_indices = sgtbx.change_of_basis_op(smx).apply(miller_indices) rms = miller_set(cs, reindexed_miller_indices) rms = rms.array(data) # if params.d_min or params.d_max: # rms = rms.resolution_filter(d_min=params.d_min, d_max=params.d_max) # if map_to_asu: # rms = rms.map_to_asu() intensity, intensity_rdx = rms.common_sets(ms) cc = intensity.correlation(intensity_rdx).coefficient() ccs.append(cc) offsets.append((h, k, l)) nref.append(intensity.size()) return offsets, ccs, nref
def get_hkl_offset_correlation_coefficients( dials_reflections, dials_crystal, map_to_asu=False, grid_h=0, grid_k=0, grid_l=0, reference=None, ): # N.B. deliberately ignoring d_min, d_max as these are inconsistent with # changing the miller indices from cctbx import sgtbx from cctbx.miller import set as miller_set from dials.array_family import flex cs = cctbx_crystal_from_dials(dials_crystal) ms = cctbx_i_over_sigi_ms_from_dials_data(dials_reflections, cs) if reference: reference_ms = cctbx_i_over_sigi_ms_from_dials_data(reference, cs) else: reference_ms = None ccs = flex.double() offsets = flex.vec3_int() nref = flex.size_t() if reference: cb_op = sgtbx.change_of_basis_op("x,y,z") else: cb_op = sgtbx.change_of_basis_op("-x,-y,-z") hkl_test = [ (h, k, l) for h in range(-grid_h, grid_h + 1) for k in range(-grid_k, grid_k + 1) for l in range(-grid_l, grid_l + 1) ] for hkl in hkl_test: indices = offset_miller_indices(ms.indices(), hkl) reindexed_indices = cb_op.apply(indices) rms = miller_set(cs, reindexed_indices).array(ms.data()) if reference_ms: _ms = reference_ms else: _ms = miller_set(cs, indices).array(ms.data()) n, cc = compute_miller_set_correlation(_ms, rms, map_to_asu=map_to_asu) ccs.append(cc) offsets.append(hkl) nref.append(n) return offsets, ccs, nref
def cctbx_i_over_sigi_ms_from_dials_data(reflections, cctbx_crystal_symmetry): from dials.array_family import flex from cctbx.miller import set as miller_set refl = reflections.select(reflections['intensity.sum.variance'] > 0) return miller_set(cctbx_crystal_symmetry, refl['miller_index']).array( data=refl['intensity.sum.value'], sigmas=flex.sqrt(refl['intensity.sum.variance']))
def test_crystal_pointgroup_symmetry(reflections, experiment, params): crystal = experiment.crystal # in case we pass in reflections from integration reflections = reflections.select(reflections["intensity.sum.variance"] > 0) reflections = reflections.select(reflections["intensity.sum.value"] > 0) original_miller_indices = reflections["miller_index"] space_group = crystal.get_space_group() unit_cell = crystal.get_unit_cell() cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol()) ms = miller_set(cs, original_miller_indices) ms = ms.array(reflections["intensity.sum.value"] / flex.sqrt(reflections["intensity.sum.variance"])) if params.d_min or params.d_max: d_spacings = ms.d_spacings().data() sel = (d_spacings >= params.d_min) & (d_spacings <= params.d_max) ms = ms.select(sel) if params.normalise: if params.normalise_bins: ms = normalise_intensities(ms, n_bins=params.normalise_bins) else: ms = normalise_intensities(ms) logger.info("Check symmetry operations on %d reflections:" % ms.size()) logger.info("") logger.info("%20s %6s %5s" % ("Symop", "Nref", "CC")) true_symops = [] ccs, n_refs = get_symop_correlation_coefficients(ms) ses = standard_error_of_pearson_cc(ccs, n_refs) for smx, cc, n_ref, se in zip(space_group.smx(), ccs, n_refs, ses): accept = "" if params.symop_threshold: if (cc - 2.0 * se) > params.symop_threshold: true_symops.append(smx) accept = "***" cc_str = format_cc_with_standard_error(cc, se) logger.info("%20s %6d %s %s" % (smx, n_ref, cc_str, accept)) if params.symop_threshold: sg = sgtbx_space_group() for symop in true_symops: sg = sg.expand_smx(symop) for ltr in space_group.ltr(): sg = sg.expand_ltr(ltr) sg_symbols = sg.match_tabulated_settings() logger.info("") logger.info("Derived point group from symmetry operations: %s" % sg_symbols.hermann_mauguin()) logger.info("") return
def get_hkl_offset_correlation_coefficients( dials_reflections, dials_crystal, map_to_asu=False, grid_h=0, grid_k=0, grid_l=0, reference=None): # N.B. deliberately ignoring d_min, d_max as these are inconsistent with # changing the miller indices from dials.array_family import flex from cctbx.miller import set as miller_set from cctbx import sgtbx cs = cctbx_crystal_from_dials(dials_crystal) ms = cctbx_i_over_sigi_ms_from_dials_data(dials_reflections, cs) if reference: reference_ms = cctbx_i_over_sigi_ms_from_dials_data(reference, cs) else: reference_ms = None ccs = flex.double() offsets = flex.vec3_int() nref = flex.size_t() if reference: cb_op = sgtbx.change_of_basis_op('x,y,z') else: cb_op = sgtbx.change_of_basis_op('-x,-y,-z') hkl_test = [(h, k, l) for h in range(-grid_h, grid_h + 1) \ for k in range(-grid_k, grid_k + 1) \ for l in range(-grid_l, grid_l + 1)] for hkl in hkl_test: indices = offset_miller_indices(ms.indices(), hkl) reindexed_indices = cb_op.apply(indices) rms = miller_set(cs, reindexed_indices).array(ms.data()) if reference_ms: _ms = reference_ms else: _ms = miller_set(cs, indices).array(ms.data()) n, cc = compute_miller_set_correlation(_ms, rms, map_to_asu=map_to_asu) ccs.append(cc) offsets.append(hkl) nref.append(n) return offsets, ccs, nref
def get_amplitudes(self, dials_model, refl_table, test_without_mpi=True): D = dials_model R = refl_table from cctbx.crystal import symmetry from cctbx.miller import array, set as miller_set uc = D.crystal.get_unit_cell() sg = D.crystal.get_space_group() MS = miller_set(symmetry(unit_cell=uc, space_group=sg), anomalous_flag=True, indices=R["miller_index"].select(R["spots_order"])) self.amplitudes = array(MS, data=flex.sqrt( R["spots_mockup_shoebox_sum"].select( R["spots_order"]))) from simtbx.gpu import gpu_energy_channels recommend_device = int(os.environ.get("CCTBX_RECOMMEND_DEVICE", 0)) self.gpu_channels_singleton = gpu_energy_channels( deviceId=recommend_device)
def get_amplitudes(self, dials_model, refl_table, test_without_mpi=True): from LS49.adse13_187.cyto_batch import parse_input self.params, options = parse_input() D = dials_model R = refl_table from cctbx.crystal import symmetry from cctbx.miller import array, set as miller_set uc = D.crystal.get_unit_cell() sg = D.crystal.get_space_group() MS = miller_set(symmetry(unit_cell=uc, space_group=sg), anomalous_flag=True, indices=R["miller_index"].select(R["spots_order"])) self.amplitudes = array(MS, data=flex.sqrt( R["spots_mockup_shoebox_sum"].select( R["spots_order"]))) from simtbx.gpu import gpu_energy_channels self.gpu_channels_singleton = gpu_energy_channels( deviceId=0) # determine device by rank id later
def get_indexing_offset_correlation_coefficients(reflections, crystal, grid, d_min=None, d_max=None, map_to_asu=False, grid_h=0, grid_k=0, grid_l=0, reference=None): from dials.algorithms.symmetry import origin if grid: if grid_h == 0: grid_h = grid if grid_k == 0: grid_k = grid if grid_l == 0: grid_l = grid if True: return origin.get_hkl_offset_correlation_coefficients( reflections, crystal, map_to_asu=map_to_asu, grid_h=grid_h, grid_k=grid_k, grid_l=grid_l, reference=reference) from copy import deepcopy from dials.array_family import flex space_group = crystal.get_space_group() unit_cell = crystal.get_unit_cell() from cctbx.crystal import symmetry as crystal_symmetry cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol()) from cctbx.miller import set as miller_set data = reflections['intensity.sum.value'] / \ flex.sqrt(reflections['intensity.sum.variance']) if reference: reference = reference.select(reference['intensity.sum.variance'] > 0) reference_data = reference['intensity.sum.value'] / \ flex.sqrt(reference['intensity.sum.variance']) reference_ms = miller_set( cs, reference['miller_index']).array(reference_data) else: reference_ms = None ccs = flex.double() offsets = flex.vec3_int() nref = flex.size_t() original_miller_indices = reflections['miller_index'] ms = miller_set(cs, original_miller_indices).array(data) if d_min is not None or d_max is not None: ms = ms.resolution_filter(d_min=d_min, d_max=d_max) gh = gk = gl = grid if grid_h: gh = grid_h if grid_k: gk = grid_k if grid_l: gl = grid_l # essentially just inversion operation - this *should* have good CC - unless # we are working on a reference set where we don't reindex if reference: cb_op = sgtbx.change_of_basis_op('x,y,z') else: cb_op = sgtbx.change_of_basis_op('-x,-y,-z') for h in range(-gh, gh + 1): for k in range(-gk, gk + 1): for l in range(-gl, gl + 1): miller_indices = offset_miller_indices(ms.indices(), (h, k, l)) reindexed_miller_indices = cb_op.apply(miller_indices) rms = miller_set(cs, reindexed_miller_indices).array(data) if reference_ms: _ms = reference_ms else: _ms = miller_set(cs, miller_indices).array(data) if map_to_asu: rms = rms.map_to_asu() _ms = _ms.map_to_asu() intensity, intensity_rdx = rms.common_sets(_ms) cc = intensity.correlation(intensity_rdx).coefficient() ccs.append(cc) offsets.append((h, k, l)) nref.append(intensity.size()) return offsets, ccs, nref
def test_crystal_pointgroup_symmetry(reflections, experiment, params): crystal = experiment.crystal from dials.array_family import flex # in case we pass in reflections from integration reflections = reflections.select(reflections['intensity.sum.variance'] > 0) reflections = reflections.select(reflections['intensity.sum.value'] > 0) original_miller_indices = reflections['miller_index'] space_group = crystal.get_space_group() unit_cell = crystal.get_unit_cell() from cctbx.crystal import symmetry as crystal_symmetry cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol()) from cctbx.miller import set as miller_set ms = miller_set(cs, original_miller_indices) ms = ms.array(reflections['intensity.sum.value'] / flex.sqrt(reflections['intensity.sum.variance'])) if params.d_min or params.d_max: d_spacings = ms.d_spacings().data() sel = (d_spacings >= params.d_min) & (d_spacings <= params.d_max) ms = ms.select(sel) reflections = reflections.select(sel) if params.normalise: if params.normalise_bins: ms = normalise_intensities(ms, n_bins=params.normalise_bins) else: ms = normalise_intensities(ms) logger.info('Check symmetry operations on %d reflections:' % ms.size()) logger.info('') logger.info('%20s %6s %5s' % ('Symop', 'Nref', 'CC')) true_symops = [] ccs, n_refs = get_symop_correlation_coefficients(ms) for smx, cc, n_ref in zip(space_group.smx(), ccs, n_refs): accept = '' if params.symop_threshold: if cc > params.symop_threshold: true_symops.append(smx) accept = '***' logger.info('%20s %6d %.3f %s' % (smx, n_ref, cc, accept)) if params.symop_threshold: from cctbx.sgtbx import space_group as sgtbx_space_group sg = sgtbx_space_group() for symop in true_symops: sg = sg.expand_smx(symop) for ltr in space_group.ltr(): sg = sg.expand_ltr(ltr) sg_symbols = sg.match_tabulated_settings() logger.info('') logger.info('Derived point group from symmetry operations: %s' % \ sg_symbols.hermann_mauguin()) logger.info('') return
def test_crystal_pointgroup_symmetry(reflections, experiment, params): crystal = experiment.crystal from dials.array_family import flex # in case we pass in reflections from integration reflections = reflections.select(reflections["intensity.sum.variance"] > 0) reflections = reflections.select(reflections["intensity.sum.value"] > 0) original_miller_indices = reflections["miller_index"] space_group = crystal.get_space_group() unit_cell = crystal.get_unit_cell() from cctbx.crystal import symmetry as crystal_symmetry cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol()) from cctbx.miller import set as miller_set ms = miller_set(cs, original_miller_indices) ms = ms.array(reflections["intensity.sum.value"] / flex.sqrt(reflections["intensity.sum.variance"])) if params.d_min or params.d_max: d_spacings = ms.d_spacings().data() sel = (d_spacings >= params.d_min) & (d_spacings <= params.d_max) ms = ms.select(sel) reflections = reflections.select(sel) if params.normalise: if params.normalise_bins: ms = normalise_intensities(ms, n_bins=params.normalise_bins) else: ms = normalise_intensities(ms) print "Check symmetry operations on %d reflections:" % ms.size() print "" print "%20s %6s %5s" % ("Symop", "Nref", "CC") true_symops = [] ccs, n_refs = get_symop_correlation_coefficients(ms) for smx, cc, n_ref in zip(space_group.smx(), ccs, n_refs): accept = "" if params.symop_threshold: if cc > params.symop_threshold: true_symops.append(smx) accept = "***" print "%20s %6d %.3f %s" % (smx, n_ref, cc, accept) if params.symop_threshold: from cctbx.sgtbx import space_group as sgtbx_space_group sg = sgtbx_space_group() for symop in true_symops: sg = sg.expand_smx(symop) for ltr in space_group.ltr(): sg = sg.expand_ltr(ltr) sg_symbols = sg.match_tabulated_settings() print "" print "Derived point group from symmetry operations: %s" % sg_symbols.hermann_mauguin() print "" return
def integrate_coset(self, experiments, indexed): TRANS = self.params.integration.coset.transformation # here get a deepcopy that we are not afraid to modify: experiments_local = copy.deepcopy(experiments) print("*" * 80) print("Coset Reflections for modeling or validating the background") print("*" * 80) from dials.algorithms.profile_model.factory import ProfileModelFactory from dials.algorithms.integration.integrator import create_integrator # XXX Fixme later implement support for non-primitive lattices NKS base_set = miller_set( crystal_symmetry = symmetry( unit_cell = experiments_local[0].crystal.get_unit_cell(), space_group = experiments_local[0].crystal.get_space_group()), indices = indexed["miller_index"] ) triclinic = base_set.customized_copy( crystal_symmetry=symmetry(unit_cell = experiments_local[0].crystal.get_unit_cell(),space_group="P1")) # ================ # Compute the profile model # Predict the reflections # Create the integrator # This creates a reference to the experiment, not a copy: experiments_local = ProfileModelFactory.create(self.params, experiments_local, indexed) # for debug SLT[TRANS].show_summary() for e in experiments_local: e.crystal.set_space_group(triclinic.space_group()) Astar = e.crystal.get_A() # debug OriAstar = crystal_orientation(Astar,True) # debug OriAstar.show(legend="old ") Astarprime = sqr(Astar)* ( sqr(SLT[TRANS]._reindex_N).transpose().inverse() ) e.crystal.set_A(Astarprime) # debug OriAstarprime = crystal_orientation(Astarprime,True) # debug OriAstarprime.show(legend="new ") print("Predicting coset reflections") print("") predicted = flex.reflection_table.from_predictions_multi( experiments_local, dmin=self.params.prediction.d_min, dmax=self.params.prediction.d_max, margin=self.params.prediction.margin, force_static=self.params.prediction.force_static, ) print("sublattice total predictions %d"%len(predicted)) # filter the sublattice, keep only the coset indices miller = predicted["miller_index"] # coset of modulus 2, wherein there is a binary choice # see Sauter & Zwart, Acta D (2009) 65:553, Table 1; select the valid coset using eqn(5). coset_select_algorithm_2 = flex.bool() M_mat = SLT[TRANS].matS() # the transformation M_p = M_mat.inverse() for idx in miller: H_row = row(idx) h_orig_setting = H_row * M_p on_coset=False for icom in h_orig_setting.elems: if icom.denominator() > 1: on_coset=True; break coset_select_algorithm_2.append(on_coset) predicted = predicted.select(coset_select_algorithm_2) print("of which %d are in coset %d"%(len(predicted), TRANS)) print("") integrator = create_integrator(self.params, experiments_local, predicted) # Integrate the reflections integrated = integrator.integrate() # Delete the shoeboxes used for intermediate calculations, if requested if self.params.integration.debug.delete_shoeboxes and "shoebox" in integrated: del integrated["shoebox"] if self.params.output.composite_output: if ( self.params.output.coset_experiments_filename or self.params.output.coset_filename ): assert ( self.params.output.coset_experiments_filename is not None and self.params.output.coset_filename is not None ) n = len(self.all_coset_experiments) self.all_coset_experiments.extend(experiments_local) for i, experiment in enumerate(experiments_local): refls = integrated.select(integrated["id"] == i) refls["id"] = flex.int(len(refls), n) del refls.experiment_identifiers()[i] refls.experiment_identifiers()[n] = experiment.identifier self.all_coset_reflections.extend(refls) n += 1 else: # Dump experiments to disk if self.params.output.coset_experiments_filename: experiments_local.as_json(self.params.output.coset_experiments_filename) if self.params.output.coset_filename: # Save the reflections self.save_reflections( integrated, self.params.output.coset_filename ) rmsd_indexed, _ = calc_2D_rmsd_and_displacements(indexed) log_str = "coset RMSD indexed (px): %f\n" % (rmsd_indexed) log_str += "integrated %d\n"%len(integrated) for i in range(6): bright_integrated = integrated.select( ( integrated["intensity.sum.value"] / flex.sqrt(integrated["intensity.sum.variance"]) ) >= i ) if len(bright_integrated) > 0: rmsd_integrated, _ = calc_2D_rmsd_and_displacements(bright_integrated) else: rmsd_integrated = 0 log_str += ( "N reflections integrated at I/sigI >= %d: % 4d, RMSD (px): %f\n" % (i, len(bright_integrated), rmsd_integrated) ) for crystal_model in experiments_local.crystals(): if hasattr(crystal_model, "get_domain_size_ang"): log_str += ( ". Final ML model: domain size angstroms: %f, half mosaicity degrees: %f" % ( crystal_model.get_domain_size_ang(), crystal_model.get_half_mosaicity_deg(), ) ) print(log_str) print("")
def get_indexing_offset_correlation_coefficients( reflections, crystal, grid, d_min=None, d_max=None, map_to_asu=False, grid_h=0, grid_k=0, grid_l=0, reference=None): from dials.algorithms.symmetry import origin if grid: if grid_h == 0: grid_h = grid if grid_k == 0: grid_k = grid if grid_l == 0: grid_l = grid if True: return origin.get_hkl_offset_correlation_coefficients( reflections, crystal, map_to_asu=map_to_asu, grid_h=grid_h, grid_k=grid_k, grid_l=grid_l, reference=reference) from copy import deepcopy from dials.array_family import flex space_group = crystal.get_space_group() unit_cell = crystal.get_unit_cell() from cctbx.crystal import symmetry as crystal_symmetry cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol()) from cctbx.miller import set as miller_set data = reflections['intensity.sum.value'] / \ flex.sqrt(reflections['intensity.sum.variance']) if reference: reference = reference.select(reference['intensity.sum.variance'] > 0) reference_data = reference['intensity.sum.value'] / \ flex.sqrt(reference['intensity.sum.variance']) reference_ms = miller_set(cs, reference['miller_index']).array( reference_data) else: reference_ms = None ccs = flex.double() offsets = flex.vec3_int() nref = flex.size_t() original_miller_indices = reflections['miller_index'] ms = miller_set(cs, original_miller_indices).array(data) if d_min is not None or d_max is not None: ms = ms.resolution_filter(d_min=d_min, d_max=d_max) gh = gk = gl = grid if grid_h: gh = grid_h if grid_k: gk = grid_k if grid_l: gl = grid_l # essentially just inversion operation - this *should* have good CC - unless # we are working on a reference set where we don't reindex if reference: cb_op = sgtbx.change_of_basis_op('x,y,z') else: cb_op = sgtbx.change_of_basis_op('-x,-y,-z') for h in range(-gh, gh + 1): for k in range(-gk, gk + 1): for l in range(-gl, gl + 1): miller_indices = offset_miller_indices(ms.indices(), (h, k, l)) reindexed_miller_indices = cb_op.apply(miller_indices) rms = miller_set(cs, reindexed_miller_indices).array(data) if reference_ms: _ms = reference_ms else: _ms = miller_set(cs, miller_indices).array(data) if map_to_asu: rms = rms.map_to_asu() _ms = _ms.map_to_asu() intensity, intensity_rdx = rms.common_sets(_ms) cc = intensity.correlation(intensity_rdx).coefficient() ccs.append(cc) offsets.append((h, k, l)) nref.append(intensity.size()) return offsets, ccs, nref
def run(self): """Parse the options.""" # Parse the command line arguments params, options = self.parser.parse_args(show_diff_phil=True) self.params = params assert (len(params.input.experiments) == len(params.input.reflections) == 1), "Provide one experiment list and one reflection table" assert params.method == "summed_intensity" experiments = params.input.experiments[0].data reflections = params.input.reflections[0].data # Find the aveage unit cell for the crystals in the experiments provided weighted_relfs = flex.reflection_table() all_uc = [flex.double() for i in xrange(6)] space_group = None for expt_id, experiment in enumerate(experiments): refls = reflections.select(reflections["id"] == expt_id) unit_cell = experiment.crystal.get_unit_cell() for i in xrange(6): all_uc[i].append(unit_cell.parameters()[i]) if space_group is None: space_group = experiment.crystal.get_space_group() else: assert (space_group.type().lookup_symbol() == experiment. crystal.get_space_group().type().lookup_symbol()) # Compute the average unit cell and build a miller array with it unit_cell = uctbx.unit_cell([flex.mean(data) for data in all_uc]) cs = crystal_symmetry(unit_cell, space_group.type().lookup_symbol()) ms = miller_set(cs, reflections["miller_index"], anomalous_flag=False) ma = ms.array(reflections["intensity.sum.value"] / flex.sqrt(reflections["intensity.sum.variance"])) ma.setup_binner(n_bins=10) binner = ma.binner() mean_i = flex.double() reflections["delpsical.weights"] = flex.double(len(reflections), 0) # Iterate through the bins and compute the Wilson plot, then use it compute the weights for i in binner.range_all(): sel = binner.selection(i) if sel.count(True) == 0: mean_i.append(0) continue mean_i.append( flex.mean(reflections["intensity.sum.value"].select(sel))) reflections["delpsical.weights"].set_selected( sel, reflections["intensity.sum.value"].select(sel) * (params.summed_intensity.scale_factor / mean_i[i]), ) if params.show_weight_plots: fig = plt.figure() plt.title(str(i)) plt.hist(reflections["delpsical.weights"].select(sel)) # Show unit cell distribution and mean I print("Average uc +/- std. deviation") labels = [ "% 6s" % l for l in ["a", "b", "c", "alpha", "beta", "gamma"] ] for label, data in zip(labels, all_uc): stats = flex.mean_and_variance(data) print("%s % 6.1f +/- %6.1f" % (label, stats.mean(), stats.unweighted_sample_standard_deviation())) print("Mean I over all data") binner.show_data(mean_i, data_fmt="%.1f", show_unused=False) easy_pickle.dump(params.output.reflections, reflections) if params.show_weight_plots: plt.show()