pyffag 0.1.0

DA-based FFAG accelerator tracking using differential algebra

pyffag

DA-based FFAG accelerator tracking using differential algebra.

Built on daceypy for arbitrary-order transfer map computation through FFAG sector magnets via integration of the exact midplane Hamiltonian.

Installation

pip install pyffag

Quick start

import numpy as np
from daceypy import DA
from pyffag import sector_map, compose_sequence, compose_n, tune, twiss
from pyffag.constants import kinetic_to_brho, M_PROTON

# 150 MeV proton FFAG ring: 12 FDF-triplet cells
DA.init(7, 2)  # DA order 7, 2 variables (x, px)
Brho = kinetic_to_brho(150.0, M_PROTON)  # magnetic rigidity [T·m]

# F magnet: B(x) = 1.2 + 3.0*x + 4.0*x² [T], 12° sector
F = sector_map([1.2, 3.0, 4.0], Brho, angle=np.radians(12.0))

# D magnet: B(x) = 1.2 − 5.0*x − 5.0*x² [T], 6° sector
D = sector_map([1.2, -5.0, -5.0], Brho, angle=np.radians(6.0))

# One cell = F + D + F, full ring = 12 cells
cell = compose_sequence([F, D, F])
ring = compose_n(cell, 12)

print(f"Cell tune: {twiss(cell)['tune']:.4f}")
print(f"Ring tune: {tune(ring):.4f}")

Features

• Sector magnet tracking: Exact midplane Hamiltonian integration (no paraxial approximation) through sector magnets with polynomial field profiles B(x) = B₀ + B₁x + B₂x² + ...
• Element maps: Drift (exact), thin quadrupole, sextupole, octupole, edge kicks for rectangular magnets
• Ring operations: Map composition, N-fold composition, closed orbit finding via Newton's method with DA Jacobian
• Optics: Tune, Twiss parameters, stability check, symplecticity error

Physics

The core sector_map() integrates the equations of motion in Frenet-Serret (curvilinear) coordinates with arc length as the independent variable:

dx/ds  = (1 + hx) · px / √(1 − px²)
dpx/ds = h · √(1 − px²) − (1 + hx) · By(x) / (Bρ)

where h = 1/ρ is the reference curvature. Sector magnets have radial edge faces (no edge focusing). The exact sqrt formulation captures kinematic nonlinearities that the paraxial approximation misses.

Integration with danf

Use with danf for nonlinear normal form analysis (amplitude-dependent tune shifts, resonance driving terms):

from danf import NormalForm

nf = NormalForm(ring)
nf.compute()
print(f"ADTS: dν/dε = {nf.detuning['dnux_dJx'] / 2:.4f}")

License

MIT