def calculate_cc_int(self, odd_reflections, even_reflections):
        odd_reflections_merged = reflection_table_utils.merge_reflections(
            odd_reflections, self.params.merging.minimum_multiplicity)
        even_reflections_merged = reflection_table_utils.merge_reflections(
            even_reflections, self.params.merging.minimum_multiplicity)

        # Create target symmetry
        if self.params.merging.set_average_unit_cell:
            assert 'average_unit_cell' in (self.params.statistics).__dict__
            unit_cell = self.params.statistics.__phil_get__(
                'average_unit_cell')
        else:
            unit_cell = self.params.scaling.unit_cell
        target_symm = symmetry(
            unit_cell=unit_cell,
            space_group_info=self.params.scaling.space_group)

        # Build miller arrays
        miller_indices_odd = miller.set(target_symm,
                                        odd_reflections_merged['miller_index'],
                                        True)
        intensities_odd = miller.array(
            miller_indices_odd, odd_reflections_merged['intensity'],
            flex.double(odd_reflections_merged.size(), 1.0))

        miller_indices_even = miller.set(
            target_symm, even_reflections_merged['miller_index'], True)
        intensities_even = miller.array(
            miller_indices_even, even_reflections_merged['intensity'],
            flex.double(even_reflections_merged.size(), 1.0))

        # Calculate crosss-correlation
        self.Total_CC_OneHalf_Table = self.calculate_cross_correlation(
            intensities_odd, intensities_even)
    def calculate_cc_iso(self, reflections):
        if self.params.statistics.cciso.mtz_file == None:
            self.Total_CC_Iso_Table = None
            return

        reflections_merged = reflection_table_utils.merge_reflections(
            reflections, self.params.merging.minimum_multiplicity)

        # Create target symmetry
        if self.params.merging.set_average_unit_cell:
            assert 'average_unit_cell' in (self.params.statistics).__dict__
            unit_cell = self.params.statistics.__phil_get__(
                'average_unit_cell')
        else:
            unit_cell = self.params.scaling.unit_cell
        target_symm = symmetry(
            unit_cell=unit_cell,
            space_group_info=self.params.scaling.space_group)

        # Build miller array for experimental data
        miller_indices = miller.set(target_symm,
                                    reflections_merged['miller_index'], True)
        exp_intensities = miller.array(
            miller_indices, reflections_merged['intensity'],
            flex.double(reflections_merged.size(), 1.0))

        self.Total_CC_Iso_Table = self.calculate_cross_correlation(
            self.params.scaling.i_model, exp_intensities)
Пример #3
0
  def run(self, experiments, reflections):

    # select, merge and output odd reflections
    odd_reflections = reflection_table_utils.select_odd_experiment_reflections(reflections)
    odd_reflections_merged = reflection_table_utils.merge_reflections(odd_reflections, self.params.merging.minimum_multiplicity)
    self.gather_and_output_reflections(odd_reflections_merged, 'odd')

    # select, merge and output even reflections
    even_reflections = reflection_table_utils.select_even_experiment_reflections(reflections)
    even_reflections_merged = reflection_table_utils.merge_reflections(even_reflections, self.params.merging.minimum_multiplicity)
    self.gather_and_output_reflections(even_reflections_merged, 'even')

    # merge and output all reflections
    all_reflections_merged = reflection_table_utils.merge_reflections(reflections, self.params.merging.minimum_multiplicity)
    self.gather_and_output_reflections(all_reflections_merged, 'all')

    return None, reflections