Esempio n. 1
0
def test_operators():
    import numpy as np

    def as_np(xyz):
        return np.array([xyz.x, xyz.y, xyz.z])

    a = XYZ(5, 8, 1)
    a.x, a.y, a.z = 9, 8, 7

    assert a.x == 9
    assert a.y == 8
    assert a.z == 7

    b = XYZ(1, 2, 3)

    npa = as_np(a)
    npb = as_np(b)

    assert np.allclose(as_np(a + b), npa + npb)
    assert np.allclose(as_np(-a), -npa)
    assert np.allclose(as_np(a - b), npa - npb)
    assert np.allclose(as_np(a * 7), npa * 7)
    assert np.allclose(as_np(a / 7), npa / 7)
    assert np.allclose(as_np(7 * a), 7 * npa)
    assert np.allclose((a.dot(b)), np.dot(npa, npb))
    assert np.allclose(a.len(), np.linalg.norm(npa))
    assert np.allclose(a.len2(), np.linalg.norm(npa)**2)
    assert np.allclose(as_np(a.cross(b)), np.cross(npa, npb))
Esempio n. 2
0
def test_sasa_three_spheres():
    for samples, precision in [
        (10, 5e0),  # 5% accuracy
        (50, 1e0),  # 1% accuracy
        (250, 1e-1),  # 0.1% accuracy
        (1000, 1e-2),  # 0.01% accuracy
        (5000, 1e-3),  # 0.001% accuracy
    ]:
        for _ in range(100):
            r1, r2, r3 = np.random.random(3) * 2 + 0.01

            a = XYZ(*(np.random.random(3) * 2 - 1))
            b = XYZ(*(np.random.random(3) * 2 - 1))
            v = XYZ(*np.random.random(3))
            v /= v.len()
            c = a + v * (r1 + r3)

            S1 = 4 * np.pi * r1 ** 2
            S2 = 4 * np.pi * r2 ** 2
            S3 = 4 * np.pi * r3 ** 2

            S1_loss = first_sphere_hidden_area(a, b, r1, r2) + first_sphere_hidden_area(a, c, r1, r3)
            S2_loss = first_sphere_hidden_area(b, a, r2, r1) + first_sphere_hidden_area(b, c, r2, r3)
            S3_loss = first_sphere_hidden_area(c, a, r3, r1) + first_sphere_hidden_area(c, b, r3, r2)

            total_area = S1 + S2 + S3
            exposed_area_exact = total_area - S1_loss - S2_loss - S3_loss

            sasa = calc_sasa(VectorXYZ([a, b, c]), np.array([r1, r2, r3]), 0, n_samples=samples)
            exposed_area_approx = sum(sasa)

            exposed_area_percent_exact = exposed_area_exact / total_area * 100
            exposed_area_percent_approx = exposed_area_approx / total_area * 100

            assert np.isclose(exposed_area_percent_exact,
                              exposed_area_percent_approx,
                              atol=precision), (exposed_area_percent_exact,
                                                exposed_area_percent_approx,)