Esempio n. 1
0
def test_quad(rin):
    q = elements.Quadrupole('quad', 0.4, k=1)
    lattice = [q]
    rin[0, 0] = 1e-6
    atpass(lattice, rin, 1)
    expected = numpy.array([
        0.921060994002885, -0.389418342308651, 0, 0, 0, 0.000000010330489
    ]).reshape(6, 1) * 1e-6
    numpy.testing.assert_allclose(rin, expected)
Esempio n. 2
0
def test_quadrupole():
    q = elements.Quadrupole('quadrupole', 1.0)
    assert q.MaxOrder == 1
    assert len(q.PolynomA) == 2
    assert q.K == 0.0
    q = elements.Quadrupole('quadrupole', 1.0, -0.5)
    assert q.MaxOrder == 1
    assert len(q.PolynomA) == 2
    assert q.K == -0.5
    q = elements.Quadrupole('quadrupole', 1.0, PolynomB=[0.0, 0.0, 0.005])
    assert q.MaxOrder == 2
    assert len(q.PolynomA) == 3
    assert q.K == 0.0
    q = elements.Quadrupole('quadrupole', 1.0, PolynomB=[0.0, 0.5, 0.005],
                            MaxOrder=1)
    assert q.MaxOrder == 1
    assert len(q.PolynomA) == 3
    assert q.K == 0.5
Esempio n. 3
0
def test_quad(rin):
    q = elements.Quadrupole('quad', 0.4, k=1)
    rin[0, 0] = 1e-6
    element_pass(q, rin)
    expected = numpy.array([0.9210610203854122, -0.3894182419439, 0,
                            0, 0, 0.0000000103303797478]).reshape(6, 1) * 1e-6
    numpy.testing.assert_allclose(rin, expected)
    assert q.K == 1
    q.PolynomB[1] = 0.2
    assert q.K == 0.2
    q.K = 0.1
    assert q.PolynomB[1] == 0.1
Esempio n. 4
0
def test_argument_checks():
    q = elements.Quadrupole('quad', 1.0, 0.5)
    # Test type
    with pytest.raises(ValueError):
        q.Length = 'a'
    # Test shape
    with pytest.raises(ValueError):
        q.T1 = [0.0, 0.0]
    # Test coherence of polynoms
    with pytest.raises(ValueError):
        q.MaxOrder = 2
    with pytest.raises(ValueError):
        q.PolynomA = [0.0]
    with pytest.raises(ValueError):
        q.PolynomB = [0.0]
Esempio n. 5
0
def test_insert_into_drift():
    # Create elements
    drift = elements.Drift('drift', 1)
    monitor = elements.Monitor('bpm')
    quad = elements.Quadrupole('quad', 0.3)
    # Test None splitting behaviour
    el_list = drift.insert([(0., None), (0.3, None), (0.7, None), (1., None)])
    assert len(el_list) == 3
    numpy.testing.assert_almost_equal([e.Length for e in el_list],
                                      [0.3, 0.4, 0.3])
    # Test normal insertion
    el_list = drift.insert([(0.3, monitor), (0.7, quad)])
    assert len(el_list) == 5
    numpy.testing.assert_almost_equal([e.Length for e in el_list],
                                      [0.3, 0.0, 0.25, 0.3, 0.15])
    # Test insertion at either end produces -ve length drifts
    el_list = drift.insert([(0.0, quad), (1.0, quad)])
    assert len(el_list) == 5
    numpy.testing.assert_almost_equal([e.Length for e in el_list],
                                      [-0.15, 0.3, 0.7, 0.3, -0.15])
Esempio n. 6
0
def test_quad_incorrect_array(rin):
    q = elements.Quadrupole('quad', 0.4, k=1)
    q.PolynomB = 'a'
    lattice = [q]
    with pytest.raises(RuntimeError):
        atpass(lattice, rin, 1)