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)