def calcEmittance(self, timestep):
f = h5py.File(self.filename + "/h5/simData_{}.h5".format(timestep),
"r")
N_all = np.shape(f['/data/{}/particles/{}/momentum/x/'.format(
timestep, self.species)])[0]
handler = f['/data/{}/particles/{}/'.format(timestep, self.species)]
w = handler['weighting']
slices = np.arange(0, N_all, self.slice)
uxSI = (handler['momentum/' + self.coordinate].attrs['unitSI']
) / const.speed_of_light / const.electron_mass
positionSI = handler['position/' + self.coordinate].attrs['unitSI']
position_sq_s = 0.
pos_mom_s = 0.
momentum_sq_s = 0.
#### Hier noch die Bin Größen raus nehmen
Calc = Auswertung.Auswertung(self.filename, 1024, 20, 100,
self.species, self.slice, self.m,
timestep)
startsUnfiltered, startsFiltered = Calc.chunks(self.slice)
for i in range(len(startsFiltered) - 1):
w_s = w[startsUnfiltered[i]:startsUnfiltered[i + 1]][
self.m[startsUnfiltered[i]:startsUnfiltered[i + 1]]]
position = (handler['position/' + self.coordinate]
[startsUnfiltered[i]:startsUnfiltered[i + 1]]
[self.m[startsUnfiltered[i]:startsUnfiltered[i + 1]]] +
handler['positionOffset/' + self.coordinate]
[startsUnfiltered[i]:startsUnfiltered[i + 1]]
[self.m[startsUnfiltered[i]:startsUnfiltered[i + 1]]]
) * positionSI
momentum = (handler['momentum/' + self.coordinate]
[startsUnfiltered[i]:startsUnfiltered[i + 1]]
[self.m[startsUnfiltered[i]:startsUnfiltered[i + 1]]]
) / w_s * uxSI
N_e_slice = np.size(w_s)
if np.sum(w_s) > 0:
position_sq_s += N_e_slice * np.average(
(position**2), weights=w_s)
pos_mom_s += N_e_slice * np.average(
(position * momentum), weights=w_s)
momentum_sq_s += N_e_slice * np.average(
(momentum**2), weights=w_s)
No = Calc.N(timestep)
if No > 0:
position_sq = position_sq_s / No
pos_mom = pos_mom_s / No
momentum_sq = momentum_sq_s / No
emit = np.sqrt(position_sq * momentum_sq - pos_mom**2) / 1e-6
else:
print('alle Teilchen wurden weggefiltert')
emit = 0
f.close()
return (emit)
def SliceEmittance(self, args): #timestep, FilterDictValues):
timestep, FilterDictValues = args
f = h5py.File(self.filename + "/h5/simData_{}.h5".format(timestep),
"r")
handler = f['/data/{}/particles/{}/'.format(timestep, self.species)]
w = handler['weighting']
handlerE = f['/data/{}/fields/E'.format(timestep)]
grit_size = np.array(np.shape(handlerE['x']))
gritSpacing = handlerE.attrs['gridSpacing'] * handlerE.attrs[
'gridUnitSI']
globalPosition = np.round((handlerE.attrs['gridGlobalOffset'] *
handlerE.attrs['gridUnitSI'] * 1e6)[1],
decimals=2)
f.close()
L = grit_size[1] * gritSpacing[1] * 1e6
y = np.zeros(11)
emitS = np.zeros(11)
#args2 = []
#for i in range(0,11,1):
# args.append([i,timestep, FilterDictValues,L,globalPosition])
#pool = Pool(15)
#work=pool.map(self.workSliceEmittance,args2)
#for index in range(0,11,1):
# y[index],emitS[index] = work[index]
for i in range(0, 11, 1):
neuerFilter = h5filter.h5filter(self.filename, timestep,
self.species, self.slice_size)
self.filtern(FilterDictValues, timestep)
y[i] = globalPosition + i * L / 10
if i < 10:
y[i + 1] = globalPosition + (i + 1) * L / 10
neuerFilter.filterPosition('y', y[i] * 1e-6, y[i + 1] * 1e-6,
timestep)
#m=self.filtern(FilterDictValues,timestep)
if i == 10:
neuerFilter.filterPosition('y', y[i] * 1e-6,
(y[i] + L / 2) * 1e-6, timestep)
# m=self.filtern(FilterDictValues,timestep)
y[i] -= globalPosition
m = neuerFilter.maske
b = Auswertung.Auswertung(self.filename, 1024, 0, 150,
self.species, self.slice_size, m,
timestep)
emitS[i] = b.calcEmittance('x', timestep)
print('timestep=', timestep, 'emitS=', emitS)
return (y, emitS)
def workSliceEmittance(self, args2):
i, timestep, FilterDictValues, L, globalPosition = args2
y1 = globalPosition + i * L / 10
if i < 10:
y2 = globalPosition + (i + 1) * L / 10
neuerFilter.filterPosition('y', y1 * 1e-6, y2 * 1e-6, timestep)
m = self.filtern(FilterDictValues, timestep)
if i == 10:
neuerFilter.filterPosition('y', y1 * 1e-6, (y1 + L / 2) * 1e-6,
timestep)
m = self.filtern(FilterDictValues, timestep)
y1 -= globalPosition
b = Auswertung.Auswertung(self.filename, 1024, 0, 150, self.species,
self.slice_size, m, timestep)
emitS = b.calcEmittance('x', timestep)
return (y1, emitS)
def old_histogram():
darstellungen = PlotFkt.PlotFkt(filename, species, slice_size, [])
m = darstellungen.filtern({}, timestep.value)
b = Auswertung.Auswertung(filename, n_bins, bin_min, bin_max, species, slice_size, m, timestep.value)
return b.EnergyHistogram(timestep.value)
def workEnergyHist(self, args):
timestep, FilterDictValues = args
m = self.filtern(FilterDictValues, timestep)
b = Auswertung.Auswertung(self.filename, 1024, 0, 150, self.species,
self.slice_size, m, timestep)
return (b.EnergyHistogram(timestep))
def workEmittance(self, args):
timestep, FilterDictValues = args
m = self.filtern(FilterDictValues, timestep)
b = Auswertung.Auswertung(self.filename, 1024, 20, 100, self.species,
self.slice_size, m, timestep)
return (b.calcEmittance('x', timestep))
def useFilter(sophie):
clear_output()
display(tslider, filterCheckbox, button1, FilterContainer,
EnergyContainer, PhasenraumContainer, EmittanceContainer,
FieldContainer, button2)
#### Filtern:
FilterDictValues = {}
if filterCheckbox.children[1].value:
FilterDictValues['gamma'] = (gamma.children[0].value,
gamma.children[1].value)
if filterCheckbox.children[2].value:
FilterDictValues['x'] = [
x.children[0].value * 1e-6, x.children[1].value * 1e-6
]
if filterCheckbox.children[3].value:
FilterDictValues['y'] = [
y.children[0].value * 1e-6, y.children[1].value * 1e-6
]
if filterCheckbox.children[4].value:
FilterDictValues['z'] = [
z.children[0].value * 1e-6, z.children[1].value * 1e-6
]
if filterCheckbox.children[5].value:
FilterDictValues['ux'] = [
ux.children[0].value, ux.children[1].value
]
if filterCheckbox.children[6].value:
FilterDictValues['uz'] = [
uz.children[0].value, uz.children[1].value
]
m = Darstellungen.filtern(FilterDictValues, timestep.value)
b = Auswertung.Auswertung(filename, 1024, 20, 150, species, slice_size,
m, timestep.value)
args = []
for i in (ts_2d.iterations):
args.append([i, FilterDictValues])
####Darstellungen:
if EnergyContainer.children[1].value:
bins = np.linspace(b.bin_min, b.bin_max, b.n_bins)
plt.figure(num='Energyhistogram')
plt.plot(bins, b.EnergyHistogram(timestep.value))
plt.ylim((0, 2e7))
#plt.yscale('log')
plt.xlabel(r'E$_\mathrm{kin}$ [MeV]')
plt.ylabel(r'Anzahl Elektronen')
plt.show()
if EnergyContainer.children[2].value:
pool = Pool(15)
work = pool.map(Darstellungen.workEnergyHist, args)
Energy_list = np.zeros((1024, len(ts_2d.iterations)))
for index, iterT in enumerate(ts_2d.iterations):
Energy_list[:, index] = work[index]
plt.figure(num='Energyverlauf')
timebins = np.linspace(0, 10000, 11)
enegybins = np.linspace(0, 150, 1024)
plt.pcolormesh(timebins,
enegybins,
Energy_list,
norm=LogNorm(),
vmin=1e6,
vmax=1e8)
plt.colorbar()
if PhasenraumContainer.children[
1].value or PhasenraumContainer.children[
2].value or PhasenraumContainer.children[3].value:
plt.figure(figsize=(13.5, 4.5), num='Phasenraum')
if PhasenraumContainer.children[1].value:
positionx, momentumx = b.Phasenraum(timestep.value, 'x')
plt.subplot(131)
plt.hist2d(positionx, momentumx, bins=256, norm=LogNorm())
plt.xlabel(r'x [$\mu$m]')
plt.ylabel(r'ux [$\beta \gamma$]')
plt.colorbar()
if PhasenraumContainer.children[2].value:
positionz, momentumz = b.Phasenraum(timestep.value, 'z')
plt.subplot(
132) #sublot(Anzahl Zeilen Anzahl Spalten Bild Nummer)
plt.hist2d(positionz, momentumz, bins=256, norm=LogNorm())
plt.xlabel(r'z [$\mu$m]')
plt.ylabel(r'uz [$\beta \gamma$]')
plt.colorbar()
plt.tight_layout(pad=0.4, w_pad=1.5)
if PhasenraumContainer.children[3].value:
positiony, momentumy = b.Phasenraum(timestep.value, 'y')
plt.subplot(133)
plt.hist2d(positiony, momentumy, bins=256, norm=LogNorm())
plt.xlabel(r'y [$\mu$m]')
plt.ylabel(r'uy [$\beta \gamma$]')
plt.colorbar()
plt.show()
if EmittanceContainer.children[1].value:
e = Emittance.Emittance(filename, species, slice_size, 'x', m)
print('Emittance x=', e.calcEmittance(timestep.value),
'pi mm mrad')
if EmittanceContainer.children[2].value:
e = Emittance.Emittance(filename, species, slice_size, 'y', m)
print('Emittance y=', e.calcEmittance(timestep.value),
'pi mm mrad')
if EmittanceContainer.children[3].value:
e = Emittance.Emittance(filename, species, slice_size, 'z', m)
print('Emittance z=', e.calcEmittance(timestep.value),
'pi mm mrad')
if EmittanceContainer.children[4].value:
emit_x_list = np.zeros(len(ts_2d.iterations))
pool = Pool(15)
work = pool.map(Darstellungen.workEmittance, args)
for index, iterT in enumerate(ts_2d.iterations):
emit_x_list[index] = work[index]
plt.figure(num='Emittance')
plt.plot(ts_2d.iterations[1:], emit_x_list[1:])
plt.ylabel(r'$\epsilon_{n,x}$ [$\pi$ mm mrad]')
plt.xlabel('Zeitschritt')
plt.show()
if EmittanceContainer.children[5].value:
pool = Pool(15)
work = pool.map(Darstellungen.SliceEmittance, args)
plt.figure(figsize=(10, 17),
num='normierte slice Emittance in pi mm mrad'
) #'Verlauf Slice Emittance')
i = 0
l = len(work)
ylim_j = np.zeros(l + 1)
for res in work:
y_j, emitS_j = res
print('i=', i, 'emitS_j=', emitS_j)
ylim_j[i] = np.max(emitS_j)
i += 1
ylim = np.max(ylim_j)
i = 0
for res in work:
y_i, emitS = res #Darstellungen.SliceEmittance(timestep.value, FilterDictValues)
print('i=', i, 'emitS=', emitS)
plt.subplot(l, 1, i + 1)
plt.plot(y_i, emitS) #,label=np.str(ts_2d.iterations[i]))
plt.ylabel(np.str(ts_2d.iterations[i])
) #plt.ylabel(r'$\epsilon_{n,x}$ [$\pi$ mm mrad]')
if ylim > 0: plt.ylim(0, ylim)
i += 1
plt.xlabel('y in µm')
plt.show()
if FieldContainer.children[1].value or FieldContainer.children[
2].value or FieldContainer.children[3].value:
plt.figure(figsize=(13.5, 4.5), num='Felder')
if FieldContainer.children[1].value:
E_y, gritSpacing, grit_size = b.EField(timestep.value)
plt.subplot(131)
plt.title('E-Feld')
plt.imshow(E_y,
aspect="auto",
origin="lower",
extent=(-0.5 * grit_size[0] * gritSpacing[0] * 1e6,
+0.5 * grit_size[0] * gritSpacing[0] * 1e6,
0, grit_size[1] * gritSpacing[1] *
1e6)) #, norm=LogNorm())
plt.colorbar()
plt.xlabel(r"$x \, \mathrm{[\mu m]}$")
plt.ylabel(r"$y \, \mathrm{[\mu m]}$")
if FieldContainer.children[2].value:
B_y, gritSpacing, grit_size = b.BField(timestep.value)
plt.subplot(132)
plt.title('B-Feld')
plt.imshow(B_y,
aspect="auto",
origin="lower",
extent=(-0.5 * grit_size[0] * gritSpacing[0] * 1e6,
+0.5 * grit_size[0] * gritSpacing[0] * 1e6,
0, grit_size[1] * gritSpacing[1] *
1e6)) #, norm=LogNorm())
plt.colorbar()
plt.xlabel(r"$x \, \mathrm{[\mu m]}$")
plt.ylabel(r"$y \, \mathrm{[\mu m]}$")
plt.tight_layout(pad=0.4, w_pad=1.5)
if FieldContainer.children[3].value:
D, gritSpacing, grit_size = b.Density(timestep.value)
plt.subplot(133)
plt.title('Charge-Density')
plt.imshow(D,
aspect="auto",
origin="lower",
norm=LogNorm(),
extent=(-0.5 * grit_size[0] * gritSpacing[0] * 1e6,
+0.5 * grit_size[0] * gritSpacing[0] * 1e6,
0, grit_size[1] * gritSpacing[1] * 1e6))
plt.colorbar()
plt.xlabel(r"$x \, \mathrm{[\mu m]}$")
plt.ylabel(r"$y \, \mathrm{[\mu m]}$")
plt.show()
timestep = timestep()
timestep.value = 5000
#FilterDictValues
FDV = {
'gamma': (0, 250),
# coords in meters
'x': [-5 * 1e-6, 5 * 1e-6],
'y': [-5 * 1e-6, 5 * 1e-6],
'z': [-5 * 1e-6, 5 * 1e-6],
# units gamma beta
'ux': [-5, 5],
'uz': [-5, 5]
}
filterselection = ['Gamma', 'x', 'y', 'z', 'ux', 'uz']
Darstellungen = PlotFkt.PlotFkt(filename, species, slice_size, filterselection)
# line 70
m = Darstellungen.filtern(FDV, timestep.value)
b = Auswertung.Auswertung(filename, 1024, 20, 150, species, slice_size, m,
timestep.value)
filterselection = ['Gamma', 'x', 'y', 'z', 'ux', 'uz']
filterCheckbox = Darstellungen.createCheckbox(filterselection,
'<b>Filter:</b>')
button1.on_click(createFilter)