def do_exercise(self, verbose=False):
     xs = self.xs
     indices = self.miller_indices(xs.space_group_info())
     exp_i_2pi_functor = cctbx.math_module.cos_sin_table(1024)
     custom_fc_sq = (structure_factors.f_calc_modulus_squared(
         xs, exp_i_2pi_functor))
     std_fc_sq = (structure_factors.f_calc_modulus_squared(xs))
     deltas = flex.double()
     for h in indices:
         custom_fc_sq.linearise(h)
         std_fc_sq.linearise(h)
         deltas.append(
             abs(custom_fc_sq.f_calc - std_fc_sq.f_calc) /
             abs(std_fc_sq.f_calc))
     stats = median_statistics(deltas)
     if verbose:
         if not self.has_printed_header:
             print("f_calc and sin/cos: |tabulated - std|/|std|")
             print("median & median absolute deviation")
             self.has_printed_header = True
         print("%s: %.12g +/- %.12g" %
               (xs.space_group_info().type().hall_symbol(), stats.median,
                stats.median_absolute_deviation))
     assert stats.median < 0.01, (str(xs.space_group_info()), stats.median)
     assert stats.median_absolute_deviation < 0.005, (str(
         xs.space_group_info()), stats.median_absolute_deviation)
Beispiel #2
0
    def do_exercise(self, verbose=False):
        xs = self.xs
        sg = xs.space_group_info().group()
        origin_centric_case = sg.is_origin_centric()

        indices = self.miller_indices(xs.space_group_info())
        f = structure_factors.f_calc_modulus_squared(xs)
        f1 = structure_factors.f_calc_modulus_squared(xs)

        for h in indices:
            f.linearise(h)
            fl = f.f_calc
            f1.evaluate(h)
            fe = f1.f_calc
            assert f1.grad_f_calc is None
            assert approx_equal_relatively(fe, fl,
                                           relative_error=1e-12), (fe, fl)

        if (xs.space_group().is_origin_centric()
                and not self.inelastic_scattering):
            for h in indices:
                f.linearise(h)
                assert f.f_calc.imag == 0
                assert flex.imag(f.grad_f_calc).all_eq(0)

        eta = 1e-8
        xs_forward = xs.deep_copy_scatterers()
        f_forward = structure_factors.f_calc_modulus_squared(xs_forward)

        deltas = flex.double()
        for direction in islice(self.structures_forward(xs, xs_forward, eta),
                                self.n_directions):
            for h in indices:
                f.linearise(h)
                assert approx_equal(abs(f.f_calc)**2, f.observable)
                f_forward.linearise(h)
                diff_num = (f_forward.observable - f.observable) / eta
                diff = f.grad_observable.dot(direction)
                delta = abs(1 - diff / diff_num)
                deltas.append(delta)
        stats = median_statistics(deltas)
        tol = 1e-5
        assert stats.median < tol, (xs.space_group_info().symbol_and_number(),
                                    stats.median)
        assert stats.median_absolute_deviation < tol, (
            xs.space_group_info().symbol_and_number(),
            stats.median_absolute_deviation)
    def do_exercise(self, verbose=False):
        xs = self.xs
        sg = xs.space_group_info().group()
        origin_centric_case = sg.is_origin_centric()

        indices = self.miller_indices(xs.space_group_info())
        f = structure_factors.f_calc_modulus_squared(xs)
        f1 = structure_factors.f_calc_modulus_squared(xs)

        for h in indices:
            f.linearise(h)
            fl = f.f_calc
            f1.evaluate(h)
            fe = f1.f_calc
            assert f1.grad_f_calc is None
            assert approx_equal_relatively(fe, fl, relative_error=1e-12), (fe, fl)

        if xs.space_group().is_origin_centric() and not self.inelastic_scattering:
            for h in indices:
                f.linearise(h)
                assert f.f_calc.imag == 0
                assert flex.imag(f.grad_f_calc).all_eq(0)

        eta = 1e-8
        xs_forward = xs.deep_copy_scatterers()
        f_forward = structure_factors.f_calc_modulus_squared(xs_forward)

        deltas = flex.double()
        for direction in islice(self.structures_forward(xs, xs_forward, eta), self.n_directions):
            for h in indices:
                f.linearise(h)
                assert approx_equal(abs(f.f_calc) ** 2, f.observable)
                f_forward.linearise(h)
                diff_num = (f_forward.observable - f.observable) / eta
                diff = f.grad_observable.dot(direction)
                delta = abs(1 - diff / diff_num)
                deltas.append(delta)
        stats = median_statistics(deltas)
        tol = 1e-3
        assert stats.median < tol, (str(space_group_info), stats.median)
        assert stats.median_absolute_deviation < tol, (str(space_group_info), stats.median_absolute_deviation)
 def do_exercise(self, verbose=False):
     xs = self.xs
     indices = self.miller_indices(xs.space_group_info())
     exp_i_2pi_functor = cctbx.math_module.cos_sin_table(1024)
     custom_fc_sq = structure_factors.f_calc_modulus_squared(xs, exp_i_2pi_functor)
     std_fc_sq = structure_factors.f_calc_modulus_squared(xs)
     deltas = flex.double()
     for h in indices:
         custom_fc_sq.linearise(h)
         std_fc_sq.linearise(h)
         deltas.append(abs(custom_fc_sq.f_calc - std_fc_sq.f_calc) / abs(std_fc_sq.f_calc))
     stats = median_statistics(deltas)
     if verbose:
         if not self.has_printed_header:
             print "f_calc and sin/cos: |tabulated - std|/|std|"
             print "median & median absolute deviation"
             self.has_printed_header = True
         print "%s: %.12g +/- %.12g" % (
             xs.space_group_info().type().hall_symbol(),
             stats.median,
             stats.median_absolute_deviation,
         )
     assert stats.median < 0.01, (str(xs.space_group_info()), stats.median)
     assert stats.median_absolute_deviation < 0.005, (str(xs.space_group_info()), stats.median_absolute_deviation)