def __init__( self, reflections, experiments, nref_per_degree=None, max_sample_size=None, min_sample_size=0, close_to_spindle_cutoff=0.02, scan_margin=0.0, outlier_detector=None, weighting_strategy_override=None, ): if len(reflections) == 0: raise ValueError("Empty reflections table provided to ReflectionManager") # keep track of models self._experiments = experiments goniometers = [e.goniometer for e in self._experiments] self._axes = [ matrix.col(g.get_rotation_axis()) if g else None for g in goniometers ] self._s0vecs = [matrix.col(e.beam.get_s0()) for e in self._experiments] # unset the refinement flags (creates flags field if needed) reflections.unset_flags( flex.size_t_range(len(reflections)), flex.reflection_table.flags.used_in_refinement, ) # check that the observed beam vectors are stored: if not, compute them n_s1_set = set_obs_s1(reflections, experiments) if n_s1_set > 0: logger.debug("Set scattering vectors for %d reflections", n_s1_set) # keep track of the original indices of the reflections reflections["iobs"] = flex.size_t_range(len(reflections)) # Check for monotonically increasing value range. If not, ref_table isn't sorted, # and proceed to sort by id and panel. This is required for the C++ extension # modules to allow for nlogn subselection of values used in refinement. l_id = reflections["id"] id0 = l_id[0] for id_x in l_id[1:]: if id0 <= id_x: id0 = id_x else: reflections.sort("id") # Ensuring the ref_table is sorted by id reflections.subsort( "id", "panel" ) # Ensuring that within each sorted id block, sorting is next performed by panel break # set up the reflection inclusion criteria self._close_to_spindle_cutoff = close_to_spindle_cutoff # close to spindle self._scan_margin = DEG2RAD * scan_margin # close to the scan edge self._outlier_detector = outlier_detector # for outlier rejection self._nref_per_degree = nref_per_degree # random subsets self._max_sample_size = max_sample_size # sample size ceiling self._min_sample_size = min_sample_size # sample size floor # exclude reflections that fail some inclusion criteria refs_to_keep = self._id_refs_to_keep(reflections) self._accepted_refs_size = len(refs_to_keep) # set entering flags for all reflections reflections.calculate_entering_flags(self._experiments) # set observed frame numbers for all reflections if not already present calculate_frame_numbers(reflections, self._experiments) # reset all use flags self.reset_accepted_reflections(reflections) # put full list of indexed reflections aside and select only the reflections # that were not excluded to manage self._indexed = reflections self._reflections = reflections.select(refs_to_keep) # set exclusion flag for reflections that failed the tests refs_to_excl = flex.bool(len(self._indexed), True) refs_to_excl.set_selected(refs_to_keep, False) self._indexed.set_flags( refs_to_excl, self._indexed.flags.excluded_for_refinement ) # set weights for all kept reflections if weighting_strategy_override is not None: self._weighting_strategy = weighting_strategy_override self._weighting_strategy.calculate_weights(self._reflections) # not known until the manager is finalised self._sample_size = None
def __init__(self, reflections, experiments, nref_per_degree=None, max_sample_size=None, min_sample_size=0, close_to_spindle_cutoff=0.02, outlier_detector=None, weighting_strategy_override=None, verbosity=0): # set verbosity self._verbosity = verbosity # keep track of models self._experiments = experiments goniometers = [e.goniometer for e in self._experiments] self._axes = [matrix.col(g.get_rotation_axis()) if g else None for g in goniometers] self._s0vecs = [matrix.col(e.beam.get_s0()) for e in self._experiments] # unset the refinement flags (creates flags field if needed) reflections.unset_flags(flex.size_t_range(len(reflections)), flex.reflection_table.flags.used_in_refinement) # check that the observed beam vectors are stored: if not, compute them n_s1_set = set_obs_s1(reflections, experiments) if n_s1_set > 0 and verbosity > 0: logger.debug("Set scattering vectors for %d reflections", n_s1_set) # keep track of the original indices of the reflections reflections['iobs'] = flex.size_t_range(len(reflections)) # set up the reflection inclusion criteria self._close_to_spindle_cutoff = close_to_spindle_cutoff #too close to spindle self._outlier_detector = outlier_detector #for outlier rejection self._nref_per_degree = nref_per_degree #random subsets self._max_sample_size = max_sample_size #sample size ceiling self._min_sample_size = min_sample_size #sample size floor # exclude reflections that fail some inclusion criteria refs_to_keep = self._id_refs_to_keep(reflections) self._accepted_refs_size = len(refs_to_keep) # set entering flags for all reflections reflections['entering'] = calculate_entering_flags(reflections, self._experiments) # set observed frame numbers for all reflections if not already present calculate_frame_numbers(reflections, self._experiments) # reset all use flags self.reset_accepted_reflections(reflections) # put full list of indexed reflections aside and select only the reflections # that were not excluded to manage self._indexed = reflections self._reflections = reflections.select(flex.size_t(refs_to_keep)) # set weights for all kept reflections if weighting_strategy_override is not None: self._weighting_strategy = weighting_strategy_override self._weighting_strategy.calculate_weights(self._reflections) # not known until the manager is finalised self._sample_size = None return
def create_indexed(self, experiments, filename): print("Simulating indexed observations for {0}".format(filename)) # Extract the experiment exp = experiments[0] # print "Experiment scan range is {0},{1}".format(*exp.scan.get_oscillation_range(deg=True)) # Copy essential columns of the original reflections into a new table # (imageset_id is required for reciprocal_lattice_viewer) obs_refs = flex.reflection_table() cols = [ "id", "imageset_id", "miller_index", "panel", "s1", "flags", "entering", "xyzobs.mm.value", "xyzobs.mm.variance", "xyzcal.mm", "xyzobs.px.value", "xyzobs.px.variance", "xyzcal.px", ] for k in cols: if k in self.original_reflections.keys(): obs_refs[k] = self.original_reflections[k] x_obs, y_obs, phi_obs = obs_refs["xyzobs.mm.value"].parts() # print "Original observation scan range is {0},{1}".format( # flex.min(phi_obs) * RAD_TO_DEG, # flex.max(phi_obs) * RAD_TO_DEG) # Reset panel number to zero prior to prediction obs_refs["panel"] = obs_refs["panel"] * 0 # Predict new centroid positions from dials.algorithms.refinement.prediction import ExperimentsPredictor predictor = ExperimentsPredictor(experiments) predictor(obs_refs) # Get vectors to add as errors to the predicted centroid positions to form # new 'observations' shift_px = flex.vec3_double(self.shiftX_px, self.shiftY_px, self.shiftZ_px) px_size_mm = exp.detector[0].get_pixel_size() image_width_rad = exp.scan.get_oscillation(deg=False)[1] shift = flex.vec3_double( px_size_mm[0] * self.shiftX_px, px_size_mm[1] * self.shiftY_px, image_width_rad * self.shiftZ_px, ) obs_refs["xyzobs.px.value"] = obs_refs["xyzcal.px"] + shift_px obs_refs["xyzobs.mm.value"] = obs_refs["xyzcal.mm"] + shift x, y, z = obs_refs["xyzobs.mm.value"].parts() # print "Simulated observation scan range is {0},{1}".format( # flex.min(z) * RAD_TO_DEG, # flex.max(z) * RAD_TO_DEG) # Keep original variance estimates from spot-finding for centroids in # pixels/images, but optionally rescale for centroids in mm/rad. # Note that an overall scale factor for the variance is irrelevant to # refinement. What matters are differences in the relative scale between # the detector space and rotation parts. if self.params.recalculate_centroid_variances: var_x_px, var_y_px, var_z_px = obs_refs[ "xyzobs.px.variance"].parts() var_x_mm = var_x_px * px_size_mm[0]**2 var_y_mm = var_y_px * px_size_mm[1]**2 var_z_rd = var_z_px * image_width_rad**2 obs_refs["xyzobs.mm.variance"] = flex.vec3_double( var_x_mm, var_y_mm, var_z_rd) # Reset observed s1 vectors from dials.algorithms.refinement.refinement_helpers import set_obs_s1 obs_refs["s1"] = flex.vec3_double(len(obs_refs)) set_obs_s1(obs_refs, experiments) return obs_refs
def __init__(self, reflections, experiments, nref_per_degree=None, max_sample_size=None, min_sample_size=0, close_to_spindle_cutoff=0.02, outlier_detector=None, weighting_strategy_override=None, verbosity=0): # set verbosity self._verbosity = verbosity # keep track of models self._experiments = experiments goniometers = [e.goniometer for e in self._experiments] self._axes = [ matrix.col(g.get_rotation_axis()) if g else None for g in goniometers ] self._s0vecs = [matrix.col(e.beam.get_s0()) for e in self._experiments] # unset the refinement flags (creates flags field if needed) reflections.unset_flags(flex.size_t_range(len(reflections)), flex.reflection_table.flags.used_in_refinement) # check that the observed beam vectors are stored: if not, compute them n_s1_set = set_obs_s1(reflections, experiments) if n_s1_set > 0 and verbosity > 0: logger.debug("Set scattering vectors for %d reflections", n_s1_set) # keep track of the original indices of the reflections reflections['iobs'] = flex.size_t_range(len(reflections)) # set up the reflection inclusion criteria self._close_to_spindle_cutoff = close_to_spindle_cutoff #too close to spindle self._outlier_detector = outlier_detector #for outlier rejection self._nref_per_degree = nref_per_degree #random subsets self._max_sample_size = max_sample_size #sample size ceiling self._min_sample_size = min_sample_size #sample size floor # exclude reflections that fail some inclusion criteria refs_to_keep = self._id_refs_to_keep(reflections) self._accepted_refs_size = len(refs_to_keep) # set entering flags for all reflections reflections['entering'] = calculate_entering_flags( reflections, self._experiments) # set observed frame numbers for all reflections if not already present calculate_frame_numbers(reflections, self._experiments) # reset all use flags self.reset_accepted_reflections(reflections) # put full list of indexed reflections aside and select only the reflections # that were not excluded to manage self._indexed = reflections self._reflections = reflections.select(flex.size_t(refs_to_keep)) # set weights for all kept reflections if weighting_strategy_override is not None: self._weighting_strategy = weighting_strategy_override self._weighting_strategy.calculate_weights(self._reflections) # not known until the manager is finalised self._sample_size = None return