Exemple #1
0
class Test_calc_remaining_reference_angles_given_one():

    # TODO: These are very incomplete due to either totally failing inutuition
    #       or code!
    def setup_method(self):
        self.calc = YouHklCalculator(createMockUbcalc(None),
                                     createMockDiffractometerGeometry(),
                                     createMockHardwareMonitor(), Mock())

    def check(self, name, value, theta, tau, psi_e, alpha_e, beta_e, places=7):
        # all in deg
        alpha, beta = self.calc._calc_remaining_reference_angles(
            name, value * TORAD, theta * TORAD, tau * TORAD)
        if alpha_e is not None:
            assert_almost_equal(alpha * TODEG, alpha_e, places)
        if beta_e is not None:
            assert_almost_equal(beta * TODEG, beta_e, places)
        psi_vals = list(self.calc._calc_psi(alpha, theta * TORAD, tau * TORAD))
        if psi_e is not None:
            assert_array_almost_equal(sorted([v * TODEG for v in psi_vals]),
                                      sorted(psi_e))
        for psi in psi_vals:
            print 'psi', psi * TODEG, ' alpha:', alpha * TODEG,\
                  ' beta:', beta * TODEG

    def test_psi_given0(self):
        self.check('psi',
                   90,
                   theta=10,
                   tau=90,
                   psi_e=[-90, 90],
                   alpha_e=0,
                   beta_e=0)

    def test_psi_given1(self):
        self.check('psi',
                   92,
                   theta=0.001,
                   tau=90,
                   psi_e=[-92, 92],
                   alpha_e=2,
                   beta_e=-2)

    def test_psi_given3(self):
        self.check('psi',
                   88,
                   theta=0.001,
                   tau=90,
                   psi_e=[-88, 88],
                   alpha_e=-2,
                   beta_e=2)

    def test_psi_given4(self):
        self.check('psi',
                   0,
                   theta=0.001,
                   tau=90,
                   psi_e=[
                       0,
                   ],
                   alpha_e=-90,
                   beta_e=90,
                   places=2)

    def test_psi_given4a(self):
        self.check('psi',
                   180,
                   theta=0.001,
                   tau=90,
                   psi_e=[-180, 180],
                   alpha_e=90,
                   beta_e=-90,
                   places=2)

    def test_psi_given5(self):
        self.check('psi',
                   180,
                   theta=0.001,
                   tau=80,
                   psi_e=[-180, 180],
                   alpha_e=80,
                   beta_e=-80,
                   places=2)

    def test_a_eq_b0(self):
        self.check('a_eq_b',
                   9999,
                   theta=0.001,
                   tau=90,
                   psi_e=[-90, 90],
                   alpha_e=0,
                   beta_e=0)

    def test_alpha_given(self):
        self.check('alpha',
                   2,
                   theta=0.001,
                   tau=90,
                   psi_e=[-92, 92],
                   alpha_e=2,
                   beta_e=-2)

    def test_beta_given(self):
        self.check('beta',
                   2,
                   theta=0.001,
                   tau=90,
                   psi_e=[-88, 88],
                   alpha_e=-2,
                   beta_e=2)
class Test_calc_remaining_reference_angles_given_one():

    # TODO: These are very incomplete due to either totally failing inutuition
    #       or code!
    def setup(self):
        self.calc = YouHklCalculator(createMockUbcalc(None),
                                     createMockDiffractometerGeometry(),
                                     createMockHardwareMonitor(),
                                     Mock())

    def check(self, name, value, theta, tau, psi_e, alpha_e, beta_e):
        # all in deg
        psi, alpha, beta = self.calc._calc_remaining_reference_angles(
            name, value * TORAD, theta * TORAD, tau * TORAD)
        print 'psi', psi * TODEG, ' alpha:', alpha * TODEG,\
              ' beta:', beta * TODEG
        if psi_e is not None:
            assert_almost_equal(psi * TODEG, psi_e)
        if alpha_e is not None:
            assert_almost_equal(alpha * TODEG, alpha_e)
        if beta_e is not None:
            assert_almost_equal(beta * TODEG, beta_e)

    def test_psi_given0(self):
        self.check('psi', 90, theta=10, tau=90, psi_e=90,
                    alpha_e=0, beta_e=0)

    def test_psi_given1(self):
        self.check('psi', 92, theta=0, tau=90, psi_e=92,
                    alpha_e=2, beta_e=-2)

    def test_psi_given3(self):
        self.check('psi', 88, theta=0, tau=90, psi_e=88,
                    alpha_e=-2, beta_e=2)

    def test_psi_given4(self):
        self.check('psi', 0, theta=0, tau=90, psi_e=0,
                    alpha_e=-90, beta_e=90)

    def test_psi_given4a(self):
        self.check('psi', 180, theta=0, tau=90, psi_e=180,
                    alpha_e=90, beta_e=-90)

    def test_psi_given5(self):
        raise SkipTest
        # TODO: I don't understand why this one passes!
        self.check('psi', 180, theta=0, tau=80,
                   psi_e=180, alpha_e=80, beta_e=-80)
        self.check('psi', 180, theta=0, tau=80,
                   psi_e=180, alpha_e=90, beta_e=-90)

    def test_a_eq_b0(self):
        self.check('a_eq_b', 9999, theta=0, tau=90,
                   psi_e=90, alpha_e=0, beta_e=0)

    def test_alpha_given(self):
        self.check('alpha', 2, theta=0, tau=90,
                   psi_e=92, alpha_e=2, beta_e=-2)

    def test_beta_given(self):
        self.check('beta', 2, theta=0, tau=90,
                   psi_e=88, alpha_e=-2, beta_e=2)
#    def test_a_eq_b1(self):
#        self.check('a_eq_b', 9999, theta=20, tau=90,
#                   psi_e=90, alpha_e=10, beta_e=10)

#    def test_psi_given0(self):
#        self.check('psi', 90, theta=10, tau=45, psi_e=90,
#                    alpha_e=7.0530221302831952, beta_e=7.0530221302831952)
    
    def test_merge_nearly_equal_detector_angle_pairs_different(self):
        pairs = [(1,2), (1,2.1)]
        assert_2darray_almost_equal(
            merge_nearly_equal_pairs(pairs), pairs)

    def test_merge_nearly_equal_detector_angle_pairs_1(self):
        pairs = [(1, 2), (1, 2)]
        assert_2darray_almost_equal(
            merge_nearly_equal_pairs(pairs), [(1, 2)])

    def test_merge_nearly_equal_detector_angle_pairs_2(self):
        pairs = [(1, 2), (1, 2), (1, 2)]
        assert_2darray_almost_equal(
            merge_nearly_equal_pairs(pairs), [(1, 2)])

    def test_merge_nearly_equal_detector_angle_pairs_3(self):
        pairs = [(1, 2.2), (1, 2), (1, 2), (1, 2)]
        assert_2darray_almost_equal(
            merge_nearly_equal_pairs(pairs), [(1, 2.2), (1, 2)])

    def test_merge_nearly_equal_detector_angle_pairs_4(self):
        pairs = [(1, 2.2), (1, 2), (1, 2), (1, 2.2)]
        assert_2darray_almost_equal(
            merge_nearly_equal_pairs(pairs), [(1, 2.2), (1, 2)])
class Test_calc_remaining_reference_angles_given_one():

    # TODO: These are very incomplete due to either totally failing inutuition
    #       or code!
    def setup_method(self):
        self.calc = YouHklCalculator(createMockUbcalc(None),
                                     createMockDiffractometerGeometry(),
                                     createMockHardwareMonitor(), Mock())

    def check(self, name, value, theta, tau, psi_e, alpha_e, beta_e):
        # all in deg
        psi, alpha, beta = self.calc._calc_remaining_reference_angles(
            name, value * TORAD, theta * TORAD, tau * TORAD)
        print 'psi', psi * TODEG, ' alpha:', alpha * TODEG,\
              ' beta:', beta * TODEG
        if psi_e is not None:
            assert_almost_equal(psi * TODEG, psi_e)
        if alpha_e is not None:
            assert_almost_equal(alpha * TODEG, alpha_e)
        if beta_e is not None:
            assert_almost_equal(beta * TODEG, beta_e)

    def test_psi_given0(self):
        self.check('psi', 90, theta=10, tau=90, psi_e=90, alpha_e=0, beta_e=0)

    def test_psi_given1(self):
        self.check('psi', 92, theta=0, tau=90, psi_e=92, alpha_e=2, beta_e=-2)

    def test_psi_given3(self):
        self.check('psi', 88, theta=0, tau=90, psi_e=88, alpha_e=-2, beta_e=2)

    def test_psi_given4(self):
        self.check('psi', 0, theta=0, tau=90, psi_e=0, alpha_e=-90, beta_e=90)

    def test_psi_given4a(self):
        self.check('psi',
                   180,
                   theta=0,
                   tau=90,
                   psi_e=180,
                   alpha_e=90,
                   beta_e=-90)

    def test_psi_given5(self):
        raise SkipTest
        # TODO: I don't understand why this one passes!
        self.check('psi',
                   180,
                   theta=0,
                   tau=80,
                   psi_e=180,
                   alpha_e=80,
                   beta_e=-80)
        self.check('psi',
                   180,
                   theta=0,
                   tau=80,
                   psi_e=180,
                   alpha_e=90,
                   beta_e=-90)

    def test_a_eq_b0(self):
        self.check('a_eq_b',
                   9999,
                   theta=0,
                   tau=90,
                   psi_e=90,
                   alpha_e=0,
                   beta_e=0)

    def test_alpha_given(self):
        self.check('alpha', 2, theta=0, tau=90, psi_e=92, alpha_e=2, beta_e=-2)

    def test_beta_given(self):
        self.check('beta', 2, theta=0, tau=90, psi_e=88, alpha_e=-2, beta_e=2)


#    def test_a_eq_b1(self):
#        self.check('a_eq_b', 9999, theta=20, tau=90,
#                   psi_e=90, alpha_e=10, beta_e=10)

#    def test_psi_given0(self):
#        self.check('psi', 90, theta=10, tau=45, psi_e=90,
#                    alpha_e=7.0530221302831952, beta_e=7.0530221302831952)

    def test_merge_nearly_equal_detector_angle_pairs_different(self):
        pairs = [(1, 2), (1, 2.1)]
        assert_2darray_almost_equal(merge_nearly_equal_pairs(pairs), pairs)

    def test_merge_nearly_equal_detector_angle_pairs_1(self):
        pairs = [(1, 2), (1, 2)]
        assert_2darray_almost_equal(merge_nearly_equal_pairs(pairs), [(1, 2)])

    def test_merge_nearly_equal_detector_angle_pairs_2(self):
        pairs = [(1, 2), (1, 2), (1, 2)]
        assert_2darray_almost_equal(merge_nearly_equal_pairs(pairs), [(1, 2)])

    def test_merge_nearly_equal_detector_angle_pairs_3(self):
        pairs = [(1, 2.2), (1, 2), (1, 2), (1, 2)]
        assert_2darray_almost_equal(merge_nearly_equal_pairs(pairs), [(1, 2.2),
                                                                      (1, 2)])

    def test_merge_nearly_equal_detector_angle_pairs_4(self):
        pairs = [(1, 2.2), (1, 2), (1, 2), (1, 2.2)]
        assert_2darray_almost_equal(merge_nearly_equal_pairs(pairs), [(1, 2.2),
                                                                      (1, 2)])