class Monitor(CObject):
_typeid = 10
turns = CField(0, 'int64', default=0)
start = CField(1, 'int64', default=0)
skip = CField(2, 'int64', default=1)
rolling = CField(3, 'int64', default=0)
ref = CField(4, 'int64', default=0)
class Multipole(CObject):
_typeid = 4
order = CField(0, 'int64', const=True, default=0)
length = CField(1, 'float64', default=0.0)
hxl = CField(2, 'float64', default=0.0)
hyl = CField(3, 'float64', default=0.0)
bal = CField(4, 'float64', default=0.0, length='2 * order + 2')
def __init__(self, knl=None, ksl=None, order=None, bal=None, **nargs):
if knl is None:
knl = []
if ksl is None:
ksl = []
if order is None:
if bal is None:
order = max(len(knl), len(ksl) - 1)
else:
order = len(bal) // 2 - 1
nbal = np.zeros(2 * order + 2, dtype=float)
if bal is None:
nbal[:len(knl) * 2:2] = knl
nbal[1:len(ksl) * 2:2] = ksl
nbal[::2] /= _factorial[:order + 1]
nbal[1::2] /= _factorial[:order + 1]
else:
nbal[:len(bal)] = bal
CObject.__init__(self, order=order, bal=nbal, **nargs)
class MyObj(CObject):
_typeid = 3
a = CField(0, 'integer', default=3)
b = CField(1, 'real', default=3.0)
c = CField(2, 'real', length=4, default=1.1)
d = CField(3, 'real', length=4, default=1.2, pointer=True)
e = CField(4, 'real', length=2, default=1.3, pointer=True)
class MyObj(CObject):
_typeid = 3
typeid_id = CField(0, 'int64', default=_typeid)
length = CField(1, 'int32', default=10, const=True)
c = CField(2, 'real', length='length', default=1.1)
d = CField(3, 'uint8', length='2*length+10', default=1, pointer=True)
e = CField(4, 'real', length='length', default=1.3, pointer=True)
class BeamBeam6D(CObject):
_typeid = 9
size = CField(0, 'uint64', const=True, default=0)
data = CField(1, 'float64', default=0.0, length='size', pointer=True)
def __init__(self, data, **kwargs):
CObject.__init__(self, size=len(data), data=data, **kwargs)
class LimitRect(CObject):
_typeid = 11
min_x = CField(0, "float64", default=-1.0, alignment=8)
max_x = CField(1, "float64", default=+1.0, alignment=8)
min_y = CField(2, "float64", default=-1.0, alignment=8)
max_y = CField(3, "float64", default=+1.0, alignment=8)
def __init__(
self,
min_x=None,
max_x=None,
min_y=None,
max_y=None,
min_coord=-1.0,
max_coord=1.0,
**kwargs
):
if min_x is None and min_coord is not None:
min_x = min_coord
if min_y is None and min_coord is not None:
min_y = min_coord
if max_x is None and max_coord is not None:
max_x = max_coord
if max_y is None and max_coord is not None:
max_y = max_coord
if min_x is None:
min_x = -1.0
if max_x is None:
max_x = 1.0
if min_y is None:
min_y = -1.0
if max_y is None:
max_y = 1.0
delta_x = 0.0
delta_y = 0.0
if min_x is not None and max_x is not None:
if min_x > max_x:
min_x, max_x = max_x, min_x
delta_x = max_x - min_x
if min_y is not None and max_y is not None:
if min_y > max_y:
min_y, max_y = max_y, min_y
delta_y = max_y - min_y
if delta_x * delta_y > 0.0:
super().__init__(
min_x=min_x, max_x=max_x, min_y=min_y, max_y=max_y, **kwargs
)
else:
raise ValueError(
"min_x, max_x, min_y, max_y have to delimit "
+ "a non-vanishing rectangle; values = [{0},{1},{2},{3}]".format(
min_x, max_x, min_y, max_x
)
)
class Line(CObject):
_typeid = 0
n_elements = CField(0, "int64", const=True)
elements = CField(1, "int64", length="n_elements")
def __init__(self, cbuffer, elements=None):
if elements is None:
elements = np.arange(cbuffer.n_objects, dtype="int64")
CObject.__init__(self, n_elements=len(elements), elements=elements)
class LimitRectEllipse(CObject):
_typeid = st_LimitRectEllipse_type_id()
max_x = CField(0, "float64", default=+1.0)
max_y = CField(1, "float64", default=+1.0)
a_squ = CField(2, "float64", default=+1.0)
b_squ = CField(3, "float64", default=+1.0)
a_b_squ = CField(4, "float64")
def __init__(self,
max_x=None,
max_y=None,
a_squ=None,
b_squ=None,
**kwargs):
if max_x is None:
max_x = 1.0
if max_y is None:
max_y = 1.0
if a_squ is None and "a" in kwargs:
a = kwargs.get("a")
if a is not None and a > 0.0:
a_squ = a * a
if a_squ is None:
a_squ = 1.0
if b_squ is None and "b" in kwargs:
b = kwargs.get("b")
if b is not None and b > 0.0:
b_squ = b * b
if b_squ is None:
b_squ = 1.0
if max_x < 0.0:
raise ValueError("max_x has to be positive definite")
if max_y < 0.0:
raise ValueError("max_y has to be_positive definite")
if a_squ < 0.0 or b_squ < 0.0:
raise ValueError("a_squ and b_squ have to be positive definite")
super().__init__(max_x=max_x,
max_y=max_y,
a_squ=a_squ,
b_squ=b_squ,
a_b_squ=a_squ * b_squ,
**kwargs)
def set_half_axes(self, a, b):
return self.set_half_axes_squ(a * a, b * b)
def set_half_axes_squ(self, a_squ, b_squ):
self.a_squ = a_squ
self.b_squ = b_squ
self.a_b_squ = a_squ * b_squ
return self
class SRotation(CObject):
_typeid = 7
cos_z = CField(0, 'float64', default=1.0)
sin_z = CField(1, 'float64', default=0.0)
def __init__(self, angle=0, **nargs):
anglerad = angle / 180 * np.pi
cos_z = np.cos(anglerad)
sin_z = np.sin(anglerad)
CObject.__init__(self, cos_z=cos_z, sin_z=sin_z, **nargs)
class BeamBeam6D(CObject):
_typeid = 9
size = CField(0, 'uint64', const=True, default=0)
data = CField(1, 'float64', default=0.0, length='size', pointer=True)
def __init__(self, **kwargs):
import pysixtrack
data = pysixtrack.BB6Ddata.BB6D_init(
**{kk: kwargs[kk]
for kk in kwargs.keys() if kk != 'cbuffer'}).tobuffer()
CObject.__init__(self, size=len(data), data=data, **kwargs)
class LimitDelta(CObject):
_typeid = 14
min_delta = CField(0, "float64", default=-1e18, alignment=8)
max_delta = CField(1, "float64", default=+1e18, alignment=8)
def __init__(self, min_delta=None, max_delta=None, **kwargs):
if min_delta is None:
min_delta = -1e18
if max_delta is None:
max_delta = +1e18
super().__init__(min_delta=min_delta, max_delta=max_delta, **kwargs)
class BeamBeam4D(CObject):
_typeid = 8
size = CField(0, 'uint64', const=True, default=0)
data = CField(1, 'float64', default=0.0, length='size', pointer=True)
def __init__(self, **kwargs):
slots = ('q_part', 'N_part', 'sigma_x', 'sigma_y', 'beta_s',
'min_sigma_diff', 'Delta_x', 'Delta_y', 'Dpx_sub', 'Dpy_sub',
'enabled')
data = [kwargs[ss] for ss in slots]
CObject.__init__(self, size=len(data), data=data, **kwargs)
class Cavity(CObject):
_typeid = 5
voltage = CField(0, 'float64', default=0.0)
kfreq = CField(1, 'float64', default=0.0)
phase = CField(2, 'float64', default=0.0)
def __init__(self, voltage=0.0, frequency=0, lag=0, **nargs):
kfreq = 2 * np.pi * frequency / _clight
phase = lag / 180 * np.pi
CObject.__init__(self,
voltage=voltage,
kfreq=kfreq,
phase=phase,
**nargs)
class BeamBeam6D(CObject):
_typeid = 9
size = CField(0, "uint64", const=True, default=0)
data = CField(1, "float64", default=0.0, length="size", pointer=True)
def __init__(self, **kwargs):
if "x_bb_co" in kwargs:
import pysixtrack
params = kwargs
data = pysixtrack.BB6Ddata.BB6D_init(
q_part=qe,
phi=params["phi"],
alpha=params["alpha"],
delta_x=params["x_bb_co"],
delta_y=params["y_bb_co"],
N_part_per_slice=params["charge_slices"],
z_slices=params["zeta_slices"],
Sig_11_0=params["sigma_11"],
Sig_12_0=params["sigma_12"],
Sig_13_0=params["sigma_13"],
Sig_14_0=params["sigma_14"],
Sig_22_0=params["sigma_22"],
Sig_23_0=params["sigma_23"],
Sig_24_0=params["sigma_24"],
Sig_33_0=params["sigma_33"],
Sig_34_0=params["sigma_34"],
Sig_44_0=params["sigma_44"],
x_CO=params["x_co"],
px_CO=params["px_co"],
y_CO=params["y_co"],
py_CO=params["py_co"],
sigma_CO=params["zeta_co"],
delta_CO=params["delta_co"],
min_sigma_diff=params["min_sigma_diff"],
threshold_singular=params["threshold_singular"],
Dx_sub=params["d_x"],
Dpx_sub=params["d_px"],
Dy_sub=params["d_y"],
Dpy_sub=params["d_py"],
Dsigma_sub=params["d_zeta"],
Ddelta_sub=params["d_delta"],
enabled=params["enabled"],
).tobuffer()
super().__init__(size=len(data), data=data, **kwargs)
else:
super().__init__(**kwargs)
class SCInterpolatedProfile(CObject):
_typeid = st_SCInterpolatedProfile_type_id()
number_of_particles = CField(0, "float64", default=0.0)
sigma_x = CField(1, "float64", default=1.0)
sigma_y = CField(2, "float64", default=1.0)
length = CField(3, "float64", default=0.0)
x_co = CField(4, "float64", default=0.0)
y_co = CField(5, "float64", default=0.0)
interpol_data_addr = CField(6, "uint64", default=0)
line_density_prof_fallback = CField(7, "float64", default=1.0)
min_sigma_diff = CField(8, "float64", default=1e-10)
enabled = CField(9, "uint64", default=1)
def __init__(self, **kwargs):
super().__init__(**kwargs)
class DipoleEdge(CObject):
_typeid = 64
r21 = CField(0, "float64", default=0.0, alignment=8)
r43 = CField(1, "float64", default=0.0, alignment=8)
def __init__(
self,
r21=None,
r43=None,
h=None,
e1=None,
hgap=None,
fint=None,
**kwargs
):
if r21 is None and r43 is None:
ZERO = np.float64(0.0)
if hgap is None:
hgap = ZERO
if h is None:
h = ZERO
if e1 is None:
e1 = ZERO
if fint is None:
fint = ZERO
# Check that the argument e1 is not too close to ( 2k + 1 ) * pi/2
# so that the cos in the denominator of the r43 calculation and
# the tan in the r21 calculations blow up
assert not np.isclose(np.absolute(np.cos(e1)), ZERO)
corr = np.float64(2.0) * h * hgap * fint
r21 = h * np.tan(e1)
temp = (
corr / np.cos(e1) * (np.float64(1) + np.sin(e1) * np.sin(e1))
)
# again, the argument to the tan calculation should be limited
assert not np.isclose(np.absolute(np.cos(e1 - temp)), ZERO)
r43 = -h * np.tan(e1 - temp)
if r21 is not None and r43 is not None:
super().__init__(r21=r21, r43=r43, **kwargs)
else:
raise ValueError(
"DipoleEdge needs either coefficiants r21 and r43"
" or suitable values for h, e1, hgap, and fint provided"
)
class Drift(CObject):
_typeid = 2
length = CField(
0,
"float64",
default=0.0,
)
class BeamMonitor(CObject):
_typeid = 10
num_stores = CField(0, "int64", default=0, alignment=8)
start = CField(1, "int64", default=0, alignment=8)
skip = CField(2, "int64", default=1, alignment=8)
out_address = CField(3, "uint64", default=0, alignment=8)
max_particle_id = CField(4, "int64", default=0, alignment=8)
min_particle_id = CField(5, "int64", default=0, alignment=8)
is_rolling = CField(6, "int64", default=0, alignment=8)
is_turn_ordered = CField(7, "int64", default=1, alignment=8)
class BeamMonitor(CObject):
_typeid = st_BeamMonitor_type_id()
num_stores = CField(0, "int64", default=0)
start = CField(1, "int64", default=0)
skip = CField(2, "int64", default=1)
out_address = CField(3, "uint64", default=0)
max_particle_id = CField(4, "int64", default=0)
min_particle_id = CField(5, "int64", default=0)
is_rolling = CField(6, "int64", default=0)
is_turn_ordered = CField(7, "int64", default=1)
class SCCoasting(CObject):
_typeid = st_SCCoasting_type_id()
number_of_particles = CField(0, "float64", default=0.0)
circumference = CField(1, "float64", default=1.0)
sigma_x = CField(2, "float64", default=1.0)
sigma_y = CField(3, "float64", default=1.0)
length = CField(4, "float64", default=0.0)
x_co = CField(5, "float64", default=0.0)
y_co = CField(6, "float64", default=0.0)
min_sigma_diff = CField(7, "float64", default=1e-10)
enabled = CField(8, "uint64", default=1)
def __init__(self, **kwargs):
super().__init__(**kwargs)
class SRotation(CObject):
_typeid = st_SRotation_type_id()
cos_z = CField(0, "real", default=1.0)
sin_z = CField(1, "real", default=0.0)
def __init__(self, angle=0, **nargs):
anglerad = angle / 180 * np.pi
cos_z = np.cos(anglerad)
sin_z = np.sin(anglerad)
super().__init__(cos_z=cos_z, sin_z=sin_z, **nargs)
@property
def angle(self):
return np.arctan2(self.sin_z, self.cos_z)
@property
def angle_deg(self):
return self.angle * (180.0 / np.pi)
class GenericObj(CObject):
_typeid = 99999
type_id = CField(0, "int64", default=_typeid, alignment=8)
a = CField(1, "int32", default=0, alignment=8)
b = CField(2, "real", default=0.0, alignment=8)
c = CField(3, "real", length=4, default=0.0, alignment=8)
num_d = CField(4, "uint64", const=True, default=0, alignment=8)
d = CField(5,
"uint8",
default=0,
pointer=True,
length="num_d",
alignment=8)
num_e = CField(6, "uint64", const=True, default=0, alignment=8)
e = CField(7,
"real",
default=0.0,
pointer=True,
length="num_e",
alignment=8)
def __init__(self, num_d=0, num_e=0, d=None, e=None, **kwargs):
in_d_len = d is not None and d and len(d) or 0
in_e_len = e is not None and e and len(e) or 0
d_len = max(num_d, in_d_len)
if d is None or not (d and len(d) > 0):
d = np.zeros(d_len, dtype=np.dtype("uint8"))
elif d and len(d) > 0:
_d = np.zeros(d_len, dtype=np.dtype("uint8"))
_d[:len(d)] = d
d = _d
if d is not None and len(d) == d_len:
kwargs["d"] = d
e_len = max(num_e, in_e_len)
if e is None or not (e and len(e) > 0):
e = np.zeros(e_len, dtype=np.dtype("float64"))
elif e and len(e) > 0:
_e = np.zeros(e_len, dtype=np.dtype("float64"))
_e[:len(e)] = e
e = _e
if e is not None and len(e) == e_len:
kwargs["e"] = e
kwargs["num_d"] = d_len
kwargs["num_e"] = e_len
CObject.__init__(self, **kwargs)
class SpaceChargeCoasting(CObject):
_typeid = 34
size = CField(0, "uint64", const=True, default=0)
data = CField(1, "float64", default=0.0, length="size", pointer=True)
def __init__(self, **kwargs):
if "sigma_x" in kwargs:
slots = (
"line_density",
"sigma_x",
"sigma_y",
"length",
"x_co",
"y_co",
"min_sigma_diff",
"enabled",
)
data = [kwargs[ss] for ss in slots]
super().__init__(size=len(data), data=data, **kwargs)
else:
super().__init__(**kwargs)
class MyObj(CObject):
_typeid = 3
typeid_id = CField(0, 'int64', default=_typeid)
a = CField(1, 'int32', default=3)
b = CField(2, 'real', default=3.0)
c = CField(3, 'real', length=4, default=1.1)
d = CField(4, 'uint8', length=4, default=1, pointer=True)
e = CField(5, 'real', length=2, default=1.3, pointer=True)
class LimitEllipse(CObject):
_typeid = st_LimitEllipse_type_id()
a_squ = CField(0, "float64", default=+1.0)
b_squ = CField(1, "float64", default=+1.0)
a_b_squ = CField(2, "float64")
def __init__(self, a_squ=None, b_squ=None, **kwargs):
if a_squ is None and "a" in kwargs:
a = kwargs.get("a")
if a is not None and a > 0.0:
a_squ = a * a
if a_squ is None:
a_squ = 1.0
if b_squ is None and "b" in kwargs:
b = kwargs.get("b")
if b is not None and b > 0.0:
b_squ = b * b
if b_squ is None:
b_squ = 1.0
if a_squ > 0.0 and b_squ > 0.0:
a_b_squ = a_squ * b_squ
super().__init__(a_squ=a_squ,
b_squ=b_squ,
a_b_squ=a_squ * b_squ,
**kwargs)
else:
raise ValueError("a_squ and b_squ have to be positive definite")
def set_half_axes(self, a, b):
return self.set_half_axes_squ(a * a, b * b)
def set_half_axes_squ(self, a_squ, b_squ):
self.a_squ = a_squ
self.b_squ = b_squ
self.a_b_squ = a_squ * b_squ
return self
class SpaceChargeBunched(CObject):
_typeid = 35
size = CField(0, "uint64", const=True, default=0)
data = CField(1, "float64", default=0.0, length="size", pointer=True)
def __init__(self, **kwargs):
if "sigma_x" in kwargs:
slots = (
"number_of_particles",
"bunchlength_rms",
"sigma_x",
"sigma_y",
"length",
"x_co",
"y_co",
"min_sigma_diff",
"enabled",
)
data = [kwargs[ss] for ss in slots]
super().__init__(size=len(data), data=data, **kwargs)
else:
super().__init__(**kwargs)
class RFMultipole(CObject):
_typeid = 10
order = CField(0, 'int64', const=True, default=0)
length = CField(1, 'float64', default=0.0)
bal = CField(2, 'float64', default=0.0, length='4 * order + 2')
def __init__(self,
knl=None,
ksl=None,
phn=None,
phs=None,
order=None,
bal=None,
**nargs):
if order is None:
if bal is None:
order = max(len(knl), len(ksl)) - 1
else:
order = len(bal) // 4 - 1
nbal = np.zeros(4 * order + 2, dtype=float)
if bal is None:
nbal[:len(knl) * 2:4] = knl
nbal[1:len(ksl) * 2:4] = ksl
nbal[::4] /= factorial[:order + 1]
nbal[1::4] /= factorial[:order + 1]
nbal[3:len(phn) * 2:4] = phn
nbal[4:len(phs) * 2:4] = phs
else:
nbal[:len(bal)] = bal
CObject.__init__(self,
order=order,
length=length,
hxl=hxl,
hyl=hyl,
bal=nbal,
**nargs)
class BeamBeam4D(CObject):
_typeid = st_BeamBeam4D_type_id()
size = CField(0, "uint64", const=True, default=0)
data = CField(1, "float64", default=0.0, length="size", pointer=True)
def __init__(self, **kwargs):
if "x_bb" in kwargs:
slots = (
"charge",
"sigma_x",
"sigma_y",
"beta_r",
"min_sigma_diff",
"x_bb",
"y_bb",
"d_px",
"d_py",
"enabled",
)
data = [qe] + [kwargs[ss] for ss in slots]
super().__init__(size=len(data), data=data, **kwargs)
else:
super().__init__(**kwargs)
class DriftExact(CObject):
_typeid = 3
length = CField(0, 'float64', default=0.0)
class XYShift(CObject):
_typeid = 6
dx = CField(0, 'float64', default=0.0)
dy = CField(1, 'float64', default=0.0)