def match_tunes(lat, tw0, quads, nu_x, nu_y, ncells=1, print_proc=0):
print("matching start .... ")
end = Monitor(eid="end")
lat = MagneticLattice(lat.sequence + [end])
# tw0.E = lat.energy
tws = twiss(lat, tw0, nPoints=None)
nu_x_old = tws[-1].mux / 2 / pi * ncells
nu_y_old = tws[-1].muy / 2 / pi * ncells
# print nu_y, nu_y_old
strengths1 = [p.k1 for p in quads]
constr = {
end: {
'mux': 2 * pi * nu_x / ncells,
'muy': 2. * pi * nu_y / ncells
},
'periodic': True
}
# print constr
vars = quads
match(lat, constr, vars, tws[0])
for i, q in enumerate(quads):
print(q.id, ".k1: before: ", strengths1[i], " after: ", q.k1)
lat = MagneticLattice(lat.sequence[:-1])
tws = twiss(lat, tw0, nPoints=None)
print("nu_x: before: ", nu_x_old, "after: ", tws[-1].mux / 2 / pi * ncells)
print("nu_y: before: ", nu_y_old, "after: ", tws[-1].muy / 2 / pi * ncells)
print("matching end.")
return lat
def bump_4cors(lat: MagneticLattice, cor_list: List[Element], marker: Union[Marker, Monitor],
x: float = 0.0001, xp: float = 0., energy: float = 14.) -> np.array:
"""
Bump with 4 correctors.
Function calculates correctors angles (strength) to make closed bump with (x, x') or (y, y') at the marker position.
Calculated angles are applied to corresponding correctors (MagneticLattice is mutated).
:param lat: MagneticLattice
:param cor_list: list of 4 correctors, All for correctors must be in the same plane
:param marker: Marker or Monitor. It must be between 2d and 3d corrector
:param x: x or y beam coordinate at Marker position [m]
:param xp: x' or y' beam coordinate at Marker position [rad]
:param energy: Beam energy [GeV]
:return: numpy array of corrector angles in [rad]
"""
# lattice analysis, calculate R matrices between different devices
if len(cor_list) != 4:
raise TypeError("It must be 4 correctors")
if len([cor for cor in cor_list if isinstance(cor, Hcor)]) == 4:
x_idx, xp_idx = 0, 1
elif len([cor for cor in cor_list if isinstance(cor, Vcor)]) == 4:
x_idx, xp_idx = 2, 3
else:
raise TypeError("Not all correctors belong to Y- or X-plane")
Rs = []
sorted_list = [cor_list[0], cor_list[1], marker, cor_list[2], cor_list[3]]
for i in range(4):
sequence = copy.deepcopy(lat.get_sequence_part(start=sorted_list[i], stop=sorted_list[i + 1]))
sequence[0].l /= 2.
sequence[-1].l /= 2.
lat1 = MagneticLattice(sequence)
R1 = lattice_transfer_map(lat1, energy)
Rs.append(R1)
R21 = np.dot(Rs[1], Rs[0])
M = np.array([[R21[x_idx, xp_idx], Rs[1][x_idx, xp_idx]],
[R21[xp_idx, xp_idx], Rs[1][xp_idx, xp_idx]]])
Minv = np.linalg.inv(M)
X = np.array([x, xp])
cor_strengths = np.dot(Minv, X)
angle_1, angle_2 = cor_strengths
R43 = np.dot(Rs[3], Rs[2])
Xf = np.array([0., 0.])
M43 = np.array([[R43[x_idx, x_idx], R43[x_idx, xp_idx]],
[R43[xp_idx, x_idx], R43[xp_idx, xp_idx]]])
X4 = np.dot(M43, X)
angle_3 = (Xf[0] - X4[0]) / Rs[3][x_idx, xp_idx]
angle_4 = -(X4[1] + Rs[3][xp_idx, xp_idx] * angle_3 - Xf[1])
a = np.array([angle_1, angle_2, angle_3, angle_4])
for i, cor in enumerate(cor_list):
cor.angle = a[i]
lat.update_transfer_maps()
return a
def rematch(beta_mean, l_fodo, qdh, lat, extra_fodo, beam, qf, qd):
'''
requires l_fodo to be defined in the lattice
'''
k, betaMin, betaMax, __ = fodo_parameters(betaXmean=beta_mean,
L=l_fodo,
verbose=True)
k1 = k[0] / qdh.l
tw0 = Twiss(beam)
_logger.debug(
'before rematching k=%f %f beta=%f %f alpha=%f %f' %
(qf.k1, qd.k1, tw0.beta_x, tw0.beta_y, tw0.alpha_x, tw0.alpha_y))
# print('before rematching k=%f %f beta=%f %f alpha=%f %f' % (qf.k1, qd.k1, tw0.beta_x, tw0.beta_y, tw0.alpha_x, tw0.alpha_y))
extra = MagneticLattice(extra_fodo)
tws = twiss(extra, tw0)
tw2 = tws[-1]
tw2m = Twiss(tw2)
tw2m.beta_x = betaMin[0]
tw2m.beta_y = betaMax[0]
tw2m.alpha_x = 0.0
tw2m.alpha_y = 0.0
tw2m.gamma_x = (1 + tw2m.alpha_x * tw2m.alpha_x) / tw2m.beta_x
tw2m.gamma_y = (1 + tw2m.alpha_y * tw2m.alpha_y) / tw2m.beta_y
#k1 += 0.5
qf.k1 = k1
qd.k1 = -k1
qdh.k1 = -k1
lat.update_transfer_maps()
extra.update_transfer_maps()
R1 = lattice_transfer_map(extra, beam.E)
Rinv = np.linalg.inv(R1)
m1 = TransferMap()
m1.R = lambda e: Rinv
tw0m = m1.map_x_twiss(tw2m)
_logger.debug(
'after rematching k=%f %f beta=%f %f alpha=%f %f' %
(qf.k1, qd.k1, tw0m.beta_x, tw0m.beta_y, tw0m.alpha_x, tw0m.alpha_y))
# print ('after rematching k=%f %f beta=%f %f alpha=%f %f' % (qf.k1, qd.k1, tw0m.beta_x, tw0m.beta_y, tw0m.alpha_x, tw0m.alpha_y))
beam.beta_x, beam.alpha_x = tw0m.beta_x, tw0m.alpha_x
beam.beta_y, beam.alpha_y = tw0m.beta_y, tw0m.alpha_y
def prepare_el_optics(beam, lat_pkg, E_photon=None, beta_av=None, s=None):
from ocelot.rad.undulator_params import Ephoton2K
# if s is None:
# jj = beam.I / (beam.beta_x * beam.beta_y * beam.emit_x * beam.emit_y)
# jj = beam.I
# s = beam.s[jj.argmax()]
if s is None:
beam_match = get_beam_peak(beam)
else:
beam_match = beam.get_s(s)
lat, extra_fodo, cell = lat_pkg
indx_und = np.where([i.__class__ == Undulator for i in lat.sequence])[0]
und = lat.sequence[indx_und[0]]
l_fodo = MagneticLattice(cell).totalLen / 2
if E_photon is not None:
und.Kx = Ephoton2K(E_photon, und.lperiod, beam_match.E)
if np.isnan(und.Kx):
gamma = beam_match.E / m_e_GeV
Emax = 2 * gamma**2 / und.lperiod * h_eV_s * speed_of_light
_logger.error(
'requested photon energy {}eV is beyond reach for given lperiod {}m and beam energy {}GeV\nmax energy for given parameters is {}'
.format(E_photon, und.lperiod, beam_match.E, Emax))
raise ValueError(
'requested photon energy is beyond reach for given parameters')
if beta_av is None:
l_period = und.lperiod
K_peak = np.max([und.Kx, und.Ky])
if und.Kx != und.Ky:
iwityp = 0 # planar undulator
elif und.Kx == und.Ky:
iwityp = 1 # helical undulator
else:
raise ValueError(
'unknown undulator: neither planar nor helical, estimation method not applicable'
)
fel = beam2fel(beam_match, l_period, K_peak, iwityp=iwityp)
beta_av = fel.beta_opt(apply=0, method=fel.method)
if beta_av <= l_fodo * 2:
beta_av = l_fodo * 2 * 1.001
raise_min_beta = True
_logger.info(
'optimal minimal average beta function was estimated and set to {:.3f}m'
.format(beta_av))
else:
raise_min_beta = False
rematch_beam_lat(beam_match,
lat_pkg,
beta_av,
raise_min_beta=raise_min_beta)
transform_beam_twiss(beam, Twiss(beam_match), s=s)
def create_fel_lattice_tmp(und_N=34,
und_L=5,
und_l=0.04,
und_Kx=0,
und_Ky=0,
inters_L=1.08,
inters_K='K_und',
inters_phi=0,
quad_L=0.1,
quad_K=0,
phs_L=0.0,
quad_start='d',
**kwargs):
if quad_L > inters_L:
_logger.warning('Quadrupole cannot be longer than intersection')
# und_n = np.floor(und_L/und_l).astype(int)
und_n = und_L / und_l
und = Undulator(nperiods=und_n,
lperiod=und_l,
Kx=und_Kx,
Ky=und_Ky,
eid="und")
qf = Quadrupole(l=quad_L / 2, eid="qf", k1=1)
qd = Quadrupole(l=quad_L / 2, eid="qd", k1=-1)
qfh = Quadrupole(l=qf.l / 2., k1=1)
qdh = Quadrupole(l=qd.l / 2., k1=-1)
phs = UnknownElement(
l=0
) #phase shifter (defines expected retardation of electrons in intersections between undulators)
phs.phi = inters_phi
phs.K = inters_K #overrides phi, would be K of free space, identical to rms K_und if "K_und"
d1 = Drift(l=(inters_L - quad_L) / 2, eid="d1") #drift
d2 = Drift(l=(inters_L - quad_L) / 2, eid="d2")
if und_N < 2:
cell_N = 0
cell_N_last = 0
else:
cell_N = np.floor((und_N) / 2).astype(int)
cell_N_last = int((und_N) / 2 % 1)
if quad_start == 'd':
cell = (qd, phs, d2, und, d1, qf, qf, phs, d2, und, d1, qd)
# extra_fodo = (und, d2, qfh)
lat = cell_N * cell + cell_N_last * (und, )
elif quad_start == 'f':
cell = (qf, phs, d2, und, d1, qd, qd, phs, d2, und, d1, qf)
# extra_fodo = (und, d2, qdh)
lat = cell_N * cell + cell_N_last * (und, )
return (MagneticLattice(lat), None, cell)
def convert_cors2dipoles(lat: MagneticLattice, cor_list: List[Element], energy: float = 10.) -> MagneticLattice:
"""
Function converts correctors with non zero angles to dipoles
:param lat: MagneticLattice
:param cor_list: list of correctors
:param energy: beam energy
:return: new MagneticLattice
"""
# track a particle through lattice with correctors
plist = lattice_track(lat, Particle(E=energy))
splist = np.array([p.s for p in plist])
# calculate edge positions for all elements
L = 0.
for elem in lat.sequence:
elem.s0 = L
L += elem.l
elem.s1 = L
# create dipoles
dipoles = []
for corr in cor_list:
scor = [corr.s0, corr.s1]
ins1 = [np.argmin(np.abs(splist - sbpm)) for sbpm in scor]
if isinstance(corr, Hcor):
p_str = "px"
tilt = 0.
else:
p_str = "py"
tilt = np.pi/2
edges = []
for i in range(2):
edges.append(plist[ins1[i]].__dict__[p_str])
dipoles.append(Bend(l=corr.l, angle=corr.angle, e1=edges[0], e2=edges[1], tilt=tilt, eid=corr.id))
# create new sequence with substituted correctors by dipoles
seq = []
for i, elem in enumerate(lat.sequence):
if elem in cor_list:
for d in dipoles:
if elem.id == d.id:
seq.append(d)
else:
if elem.__class__ is Edge:
continue
seq.append(elem)
lat_new = MagneticLattice(seq)
return lat_new
def create_copy(lattice, nsuperperiods):
lat_copy_seg = []
for i in range(nsuperperiods):
for n, elem in enumerate(lattice.sequence):
lat_copy_seg.append(copy.deepcopy(elem))
if lat_copy_seg[-1].id is None:
lat_copy_seg[-1].id = lat_copy_seg[-1].type[:2] + "_sp" + str(
i) + "_" + str(n)
else:
if elem.__class__ != Sextupole:
lat_copy_seg[-1].id = lat_copy_seg[-1].id + "_sp" + str(
i) + "_" + str(n)
return MagneticLattice(lat_copy_seg, method=lattice.method)
def create_fel_lattice(
und_N=35,
und_L=5,
und_l=0.04,
und_K=0.999,
inters_L=1.08,
quad_L=0.4,
quad_K=0,
phs_L=0.1,
phs_K=0,
quad_start='d',
):
if quad_L > inters_L:
raise ValueError('Quarrupole cannot be longer than intersection')
und_n = np.floor(und_L / und_l).astype(int)
und = Undulator(nperiods=und_n, lperiod=und_l, Kx=und_K, eid="und")
qf = Quadrupole(l=quad_L, eid="qf")
qd = Quadrupole(l=quad_L, eid="qd")
qfh = Quadrupole(l=qf.l / 2.)
qdh = Quadrupole(l=qd.l / 2.)
phs = UnknownElement(l=0) #phase shift
phs.phi = 0
d1 = Drift(l=(inters_L - quad_L) / 2, eid="d1")
d2 = Drift(l=(inters_L - quad_L) / 2, eid="d2")
if und_N < 2:
cell_N = 0
cell_N_last = 0
else:
cell_N = np.floor((und_N - 1) / 2).astype(int)
cell_N_last = int((und_N - 1) / 2 % 1)
if quad_start == 'd':
cell = (und, d1, qf, phs, d2, und, d1, qd, phs, d2)
extra_fodo = (und, d2, qdh)
lat = (und, d1, qd, phs, d2) + cell_N * cell + cell_N_last * (und, )
elif quad_start == 'f':
cell = (und, d1, qd, phs, d2, und, d1, qf, phs, d2)
extra_fodo = (und, d2, qfh)
lat = (und, d1, qf, phs, d2) + cell_N * cell + cell_N_last * (und, )
return (MagneticLattice(lat), extra_fodo, cell)
def rematch_beam_lat(beam, lat_pkg, beta_mean):
lat, extra_fodo, cell = lat_pkg
l_fodo = MagneticLattice(cell).totalLen / 2
indx_q = np.where([i.__class__ == Quadrupole for i in lat.sequence])[0]
qd = lat.sequence[indx_q[0]]
qf = lat.sequence[indx_q[1]]
indx_qh = np.where([i.__class__ == Quadrupole for i in extra_fodo])[0]
qdh = extra_fodo[indx_qh[-1]]
'''
requires l_fodo to be defined in the lattice
'''
k, betaMin, betaMax, __ = fodo_parameters(betaXmean=beta_mean,
L=l_fodo,
verbose=False)
k1 = k[0] / qdh.l
tw0 = Twiss(beam)
_logger.debug(
'before rematching k=%f %f beta=%f %f alpha=%f %f' %
(qf.k1, qd.k1, tw0.beta_x, tw0.beta_y, tw0.alpha_x, tw0.alpha_y))
# print('before rematching k=%f %f beta=%f %f alpha=%f %f' % (qf.k1, qd.k1, tw0.beta_x, tw0.beta_y, tw0.alpha_x, tw0.alpha_y))
extra = MagneticLattice(extra_fodo)
tws = twiss(extra, tw0)
tw2 = tws[-1]
tw2m = Twiss(tw2)
tw2m.beta_x = betaMin[0]
tw2m.beta_y = betaMax[0]
tw2m.alpha_x = 0.0
tw2m.alpha_y = 0.0
tw2m.gamma_x = (1 + tw2m.alpha_x * tw2m.alpha_x) / tw2m.beta_x
tw2m.gamma_y = (1 + tw2m.alpha_y * tw2m.alpha_y) / tw2m.beta_y
#k1 += 0.5
qf.k1 = k1
qd.k1 = -k1
qdh.k1 = -k1
lat.update_transfer_maps()
extra.update_transfer_maps()
R1 = lattice_transfer_map(extra, beam.E)
Rinv = np.linalg.inv(R1)
m1 = TransferMap()
m1.R = lambda e: Rinv
tw0m = m1.map_x_twiss(tw2m)
_logger.debug(
'after rematching k=%f %f beta=%f %f alpha=%f %f' %
(qf.k1, qd.k1, tw0m.beta_x, tw0m.beta_y, tw0m.alpha_x, tw0m.alpha_y))
# print ('after rematching k=%f %f beta=%f %f alpha=%f %f' % (qf.k1, qd.k1, tw0m.beta_x, tw0m.beta_y, tw0m.alpha_x, tw0m.alpha_y))
beam.beta_x, beam.alpha_x = tw0m.beta_x, tw0m.alpha_x
beam.beta_y, beam.alpha_y = tw0m.beta_y, tw0m.alpha_y
exp_dir,
run_ids) # creates experimental directory with 'run_# subdirectories
#copy_this_script(os.path.basename(__file__),os.path.realpath(__file__),exp_dir) # write copy of this script to the exp_dir
# read and prepare beam file
beam = read_beam_file(beam_fileName)
# beam.ex*=1.2
# beam.ey*=1.2
beam = cut_beam(beam, [-4e-6, 1e-6])
# beam=set_beam_energy(beam, E_beam)
beam_pk = get_beam_peak(
beam
) #another object containing beam parameters at peak current position, get_beam_s() gets parameters at given position s
#beam=zero_wake_at_ipk(beam)
lat = MagneticLattice(sase1_segment(n=20))
und_l = l_fodo # undulator cell length
# lat,beam_pk=lat_beam_rematch(lat,beam_pk,beta_av) tbd
rematch(beta_av, l_fodo, qdh, lat, extra_fodo, beam_pk, qf, qd) # jeez...
#beam =transform_beam_twiss(beam,transform=[ [beam_pk.beta_x,beam_pk.alpha_x], [beam_pk.beta_y,beam_pk.alpha_y] ])
#plot_beam(beam,showfig=0,savefig=0)
#if debug:
#tw0 = Twiss(beam_pk)
#tws=twiss(lat, tw0, nPoints = 100) # to make sure the average beta exists, show twiss if needed
und.Kx = Ephoton2K(E_photon, und.lperiod, E_beam)
# calculate UR parameters (required later for input generation)
up = UndulatorParameters(und, E_beam)
if debug: up.printParameters()
def rematch_beam_lat(beam, lat_pkg, beta_mean, raise_min_beta=False):
lat, extra_fodo, cell = lat_pkg
l_fodo= MagneticLattice(cell).totalLen / 2
if beta_mean <= 2 * l_fodo:
if raise_min_beta:
_logger.warning('Desired average beta function {}m was not larger that cell length and was set to that length {}m'.format(beta_mean, 2*l_fodo*1.001))
beta_mean = 2 * l_fodo * 1.001
else:
_logger.error('Desired average beta function {}m should be larger that cell length {}m'.format(beta_mean, 2*l_fodo))
raise ValueError('Desired average beta function {}m should be larger that cell length {}m'.format(beta_mean, 2*l_fodo))
indx_q = np.where([i.__class__ == Quadrupole for i in lat.sequence])[0]
qd = lat.sequence[indx_q[0]]
qf = lat.sequence[indx_q[1]]
indx_qh = np.where([i.__class__ == Quadrupole for i in extra_fodo])[0]
qdh = extra_fodo[indx_qh[-1]]
'''
requires l_fodo to be defined in the lattice
'''
k, betaMin, betaMax, __ = fodo_parameters(betaXmean=beta_mean, L=l_fodo, verbose=False)
k1 = k[0] / qdh.l
tw0 = Twiss(beam)
_logger.debug('before rematching k=%f %f beta=%f %f alpha=%f %f' % (qf.k1, qd.k1, tw0.beta_x, tw0.beta_y, tw0.alpha_x, tw0.alpha_y))
# print('before rematching k=%f %f beta=%f %f alpha=%f %f' % (qf.k1, qd.k1, tw0.beta_x, tw0.beta_y, tw0.alpha_x, tw0.alpha_y))
extra = MagneticLattice(extra_fodo)
tws = twiss(extra, tw0)
tw2 = tws[-1]
tw2m = Twiss(tw2)
tw2m.beta_x = betaMin[0]
tw2m.beta_y = betaMax[0]
tw2m.alpha_x = 0.0
tw2m.alpha_y = 0.0
tw2m.gamma_x = (1 + tw2m.alpha_x * tw2m.alpha_x) / tw2m.beta_x
tw2m.gamma_y = (1 + tw2m.alpha_y * tw2m.alpha_y) / tw2m.beta_y
#k1 += 0.5
qf.k1 = k1
qd.k1 = -k1
qdh.k1 = -k1
lat.update_transfer_maps()
extra.update_transfer_maps()
R1 = lattice_transfer_map(extra, beam.E)
Rinv = np.linalg.inv(R1)
m1 = TransferMap()
m1.R = lambda e: Rinv
tw0m = m1.map_x_twiss(tw2m)
_logger.debug('after rematching k=%f %f beta=%f %f alpha=%f %f' % (qf.k1, qd.k1, tw0m.beta_x, tw0m.beta_y, tw0m.alpha_x, tw0m.alpha_y))
# print ('after rematching k=%f %f beta=%f %f alpha=%f %f' % (qf.k1, qd.k1, tw0m.beta_x, tw0m.beta_y, tw0m.alpha_x, tw0m.alpha_y))
beam.beta_x, beam.alpha_x = tw0m.beta_x, tw0m.alpha_x
beam.beta_y, beam.alpha_y = tw0m.beta_y, tw0m.alpha_y
rfc1 = Drift(l = 5.0) #Cavity(l=5.0, f=1.3 * GHz, v=25.5 * MV, id='rfc1')
d0 = Drift(l = 2.0)
e1 = RBend(angle = 0.1, l = 2.0)
d1 = Drift(l = 1.0)
e2 = RBend(angle = -0.1, l = 2.0)
d2 = Drift(l = 1.0)
beam = Beam()
beam.E = 1.0 # GeV
beam.sigma_E = 1.0e-3 # GeV
beam.beta_x = 10
beam.beta_y = 20
beam.emit_x = 1.e-6
beam.emit_y = 1.e-6
lat = MagneticLattice((rfc1, d0, e1, d1, e2, (d2,)*5, e2, d2, e1,d1))
tw0 = Twiss(beam)
tws=twiss(lat, tw0, nPoints = 1000)
f=plt.figure()
ax = f.add_subplot(111)
ax.set_xlim(0, lat.totalLen)
f.canvas.set_window_title('Betas [m]')
p1, = plt.plot(map(lambda p: p.s, tws), map(lambda p: p.beta_x, tws), lw=2.0)
p2, = plt.plot(map(lambda p: p.s, tws), map(lambda p: p.beta_y, tws), lw=2.0)
plt.grid(True)
ax2 = ax.twinx()
def undulator_design(A_contents):
from ocelot.cpbd.elements import Drift, Quadrupole, Undulator
from ocelot.cpbd.magnetic_lattice import MagneticLattice
from ocelot.common import globals
from ocelot.common.globals import m_e_GeV, speed_of_light, h_eV_s
from ocelot.rad.undulator_params import Ephoton2K
from ocelot.rad.undulator_params import UndulatorParameters
import numpy as np
## Taking it from the Notebook
xlamd = A_contents['xlamd']
nwig = A_contents['nwig']
E_beam = A_contents['gamma0'] * m_e_GeV
E_photon = h_eV_s * speed_of_light / float(A_contents['xlamds'])
p_beam = np.sqrt(E_beam**2 - m_e_GeV**2)
fl = A_contents['fl']
dl = A_contents['dl']
drl = A_contents['drl']
quadf = A_contents['quadf']
quadd = -A_contents['quadd']
nsec = A_contents['nsec']
drl = int((fl + drl - nwig) / 2) - 1
kw0 = float(A_contents['aw0']) / sqrt(0.5)
# Instance of the Undulator object
und = Undulator(lperiod=xlamd, nperiods=nwig, Kx=kw0)
# Calculation of the Undulator parameter from the Photon and Beam Energies)
if (A_contents['i_scan'] == 1
and A_contents['parameter'] == 'aw0') or (A_contents['in_gen']
== 1):
und.Kx = kw0
else:
if A_contents['iwityp'] == 0:
fact_typ = 1
elif A_contents['iwityp'] == 1:
fact_typ = 1 / sqrt(0.5)
und.Kx = Ephoton2K(E_photon, und.lperiod, E_beam) * fact_typ
# Drift sections (if they are the same)
d_rift = Drift(l=drl * und.lperiod)
d_rift2 = Drift(l=drl * und.lperiod)
# Definition of Quads
qf = Quadrupole(l=fl * und.lperiod, k1=0.3 * quadf / p_beam)
qd = Quadrupole(l=dl * und.lperiod, k1=0.3 * quadd / p_beam)
qdh = deepcopy(qf)
qdh.l /= 2
# Creating the cell
extra_fodo = (und, d_rift, qdh)
cell_ps = (und, d_rift, qd, d_rift2, und, d_rift, qf, d_rift2)
l_fodo = MagneticLattice(cell_ps).totalLen / 2 ##Length of fodo cell
sase3 = MagneticLattice((
qdh,
d_rift,
) + (np.ceil(nsec / 2) * cell_ps)) # Lattice with nsec modules
up = UndulatorParameters(
und, E_beam) # Instance of the Class UndulatorParameters
print('++++ Undulator Parameters +++')
up.printParameters()
return {'Undulator Parameters': up, 'Magnetic Lattice': sase3}
__author__ = "Mykola Veremchuk" import numpy as np from ocelot.cpbd.elements import Undulator from ocelot.cpbd.magnetic_lattice import MagneticLattice from ocelot.cpbd.beam import Beam from ocelot.rad.screen import Screen from ocelot.rad.radiation_py import calculate_radiation from ocelot.optics.wave import dfl_waistscan, screen2dfl, RadiationField from ocelot.gui.dfl_plot import plot_dfl, plot_dfl_waistscan # %% # generating 2D synchrotron radiation (it will take about 1-3 minute) # LOOK TUTORIAL ABOUT GENERATING SYNCHROTRON RADIATION IN demos/ipython_tutorials/9_synchrotron_radiation.ipynb und = Undulator(Kx=0.43, nperiods=500, lperiod=0.007, eid="und") lat = MagneticLattice(und) beam = Beam() beam.E = 2.5 # beam energy in [GeV] beam.I = 0.1 # beam current in [A] screen_2d = Screen() screen_2d.z = 50.0 # distance from the begining of lattice to the screen screen_2d.size_x = 0.0015 # half of screen size in [m] in horizontal plane screen_2d.size_y = 0.0015 # half of screen size in [m] in vertical plane screen_2d.ny = 200 screen_2d.nx = 200 screen_2d.start_energy = 7762 # [eV], starting photon energy screen_2d.end_energy = 7762 # [eV], ending photon energy screen_2d.num_energy = 1 # number of energy points[eV] # calculate radiation
