def loadPulse(wdir):
wfr = Wavefront()
wfr.load_hdf5(wdir)
wfr.initial_intensity = integral_intensity(wfr, bPlot = False)
return wfr
def getIntensity(fname):
wfr = Wavefront()
wfr.load_hdf5(indir + fname)
np.save(outdir1 + fname, wfr.get_intensity())
np.save(outdir2 + fname, wfr.as_complex_array()[0, :, :, :])
def testStorage(indir, fname, N=25):
for n in range(N):
wfr = Wavefront()
wfr.load_hdf5(indir + fname)
print(wfr.custom_fields['source'])
def propagate(wfr_directory, sdir, focus, analysis = False, crop = [], append = None, descriptor = "", VERBOSE = True):
print("info")
print("wavefront directory: {}".format(wfr_directory))
print("save directory: {}".format(sdir))
print("focus (i.e. beamline option): {}".format(focus))
print("analysis: {}".format(analysis))
print("crop: {}".format(crop))
print("append: {}".format(append))
for item in descriptor:
print(item)
wfr = Wavefront()
wfr.load_hdf5(wdir)
sdir = sdir + "/{}/".format(focus)
bl = get_beamline_object(ekev = 4.96, options = focus, crop = crop)
if append is not None:
for item in append:
bl.append(item[0],item[1])
wfr.log(bl, descriptor)
bl.propagate(wfr)
if analysis:
wfr.analysis()
wfr.store_hdf5(sdir)
def propagate_NVE():
wfr_directory = sys.argv[1].replace("*", "/")
job_name = "NKB_4980eV_250pC_NVE_to_EHC"
python_command = propagate_NVE
input_directory = dCache + "/NanoKB-Pulse/NVE/"
save_directory = input_directory.replace("/NVE/", "/EHC/")
mkdir_p(save_directory)
log_directory = logs
focus = "nano"
analysis = False
filename = __file__
dt = datetime.now().__str__()
function = python_command.__name__
description = "Propagate NanoKB Pulses 4.98 keV, 250 pC from Undulator NVE mirror to the EHC Screen"
append = None
print("info")
print("wavefront directory: {}".format(wfr_directory))
print("save directory: {}".format(save_directory))
print("focus (i.e. beamline option): {}".format(focus))
print("analysis: {}".format(analysis))
print("datetime: {}".format(dt))
print("filename: {}".format(filename))
print("function: {}".format(function))
print("description: {}".format(description))
wfr = Wavefront()
wfr.load_hdf5(wfr_directory)
bl = Beamline()
bl.append(Drift(2.2+3.5), propagation_parameters(1/3,1,1/3,1,'quadratic'))
bl.propagate(wfr)
wfr.custom_fields['focus'] = focus
wfr.custom_fields['job name'] = job_name
wfr.custom_fields['input directory'] = wfr_directory
wfr.custom_fields['datetime'] = dt
wfr.custom_fields['function'] = function
wfr.custom_fields['filename'] = filename
wfr.custom_fields['description'] = description
#wfr.custom_fields['bl'] = bl.__str__
if analysis:
wfr.analysis()
wfr.store_hdf5(wfr_directory.replace("/NVE/", "/EHC/"))
def superimpose(fname, params):
"""
function to add wavefronts
"""
### TODO: FIX HARDCODING OF FILENAMES ETC.
memMap = readMap(params['global'] + params['train'],
shape=params['train_shape'])
wfr = Wavefront()
wfr.load_hdf5(params['indir'] + fname)
memMap += wfr.data.arrEhor
def propagatePulses(indir, fname, outdir):
wfr = Wavefront()
wfr.load_hdf5(indir + fname)
srwlib.srwl.SetRepresElecField(wfr._srwl_wf, 'f')
storeWavefrontInfo(wfr)
bl = getSimpleBl()
bl.propagate(wfr)
wfr.store_hdf5(outdir + fname)
def propagatePulses(fname):
wfr = Wavefront()
wfr.load_hdf5(indir + fname)
srwlib.srwl.SetRepresElecField(wfr._srwl_wf, 'f')
#storeWavefrontInfo(wfr)
bl = getSPB(wfr)
#bl = getSimpleBl()
bl.propagate_sequential(wfr)
wfr.store_hdf5(outdir + fname)
plotIntensity(wfr)
def trainAnalysis():
params = setup(VERBOSE=False)
ID = 0
## get multipulse profiles
getTrain(params['indir'], params=params, mpi=True, nProc=params['nProc'])
print("Pulse Train Succesfully Added")
## load relevant train memmap
tsi = readMap(params['global'] + params['tsi'], shape=params['tsi_shape'])
tss = readMap(params['global'] + params['tss'], shape=params['tss_shape'])
tcoh = readMap(params['global'] + params['tcoh'],
shape=params['tcoh_shape'])
tesi = readMap(params['global'] + params['tesi'],
shape=params['tesi_shape'])
tesp = readMap(params['global'] + params['tesp'],
shape=params['tesp_shape'])
tcni = readMap(params['global'] + params['tcni'],
shape=params['tcni_shape'])
tcnp = readMap(params['global'] + params['tcnp'],
shape=params['tcnp_shape'])
## load multipulse for analysis prior to launch
tfr = Wavefront()
tfr.load_hdf5(params['traindir'] + params['trainwfr'])
pulseEnergy(tfr, tesi, ID, mode='integrated')
pulseEnergy(tfr, tesp, ID, mode='pulse')
print("Train Energy Calculated")
centroid(tfr, tcni, ID, mode='integrated')
centroid(tfr, tcnp, ID, mode='pulse')
print("Train Centrod Calculated")
BeamSize(tfr, mode='integrated', memMap=tsi, ID=0)
BeamSize(tfr, mode='pulse', memMap=tss, ID=0)
print("Train Beam Size Calculated")
Coherence(tfr, tcoh, ID=0, VERBOSE=True)
print("Train Coherence Calculated")
del tsi, tss, tcoh, tesi, tesp, tcni, tcnp
def getTrain(indir, params, mpi=True, nProc=1):
"""
wrapper function linear addition of a set of wavefronts parsed through from some input
directory
"""
### TODO: FIX HARDCODING OF FILENAMES ETC.
from functools import partial
if mpi:
p = partial(superimpose, params=params)
pool = Pool(processes=nProc)
pool.map(p, iterable=os.listdir(indir))
wfr = Wavefront()
wfr.load_hdf5(params['indir'] + os.listdir(params['indir'])[
np.random.randint(0, len(os.listdir(params['indir'])))])
wfr.data.arrEhor = readMap(params['global'] + params['train'],
shape=params['train_shape'])
wfr.store_hdf5(params['traindir'] + params['trainwfr'])
srwlib.srwl.SetRepresElecField(wfr._srwl_wf, 'f')
#look_at_q_space(wfr)
return wfr
def simpleProp(wfr):
print(calculate_fwhm(wfr))
bl = Beamline()
#bl.append(Aperture('c','a', 500e-06),propagation_parameters(1,1,1,1,mode = 'normal'))
bl.append(Drift(100), propagation_parameters(1,1,1,1,mode = 'quadratic'))
#bl.append(Drift(100), propagation_parameters(1,1,1,1,mode = 'quadratic'))
bl.propagate(wfr)
plotIntensity(wfr)
print(calculate_fwhm(wfr))
if __name__ == "__main__":
#wfr = constructPulse()
wfr = Wavefront()
wfr.load_hdf5("../../data/h5/gauss.h5")
srwlib.srwl.SetRepresElecField(wfr._srwl_wf, 'f')
plotIntensity(wfr)
simpleProp(wfr)
#comparePulses(wfr, cwfr, "/data/")
__maintainer__ = "Trey Guest" __email__ = "*****@*****.**" __status__ = "Developement" """ import os, shutil from os.path import exists import json import numpy as np import h5py from matplotlib import pyplot as plt import matplotlib as mpl from wpg.wpg_uti_wf import integral_intensity import h5py from felpy.model.wavefront import Wavefront from wpg.wpg_uti_wf import animate, plot_axial_power_density, plot_total_power filename = "../../data/test_h5/XFEL_S1_04.96keV_12.0GeV_0020pC_SASE_U_BLI_2014-05-01_FAST_FXY1_0002020.h5" wfr = Wavefront() wfr.load_hdf5(filename) #animate(wfr, delay = 2, outdir = "../../tmp") plot_axial_power_density(wfr, spectrum=False, outdir="../../tmp") plot_axial_power_density(wfr, spectrum=True, outdir="../../tmp") plot_total_power(wfr, spectrum=False, outdir="../../tmp") plot_total_power(wfr, spectrum=True, outdir="../../tmp") print(integral_intensity(wfr))
def load_wfr(indir):
wfr = Wavefront()
wfr.load_hdf5(indir)
return wfr
params = setup(VERBOSE=True)
bsi = readMap(params['global'] + params['bsi'], shape=params['bsi_shape'])
bss = readMap(params['global'] + params['bss'], shape=params['bss_shape'])
coh = readMap(params['global'] + params['coh'], shape=params['coh_shape'])
esi = readMap(params['global'] + params['esi'], shape=params['esi_shape'])
esp = readMap(params['global'] + params['esp'], shape=params['esp_shape'])
cni = readMap(params['global'] + params['cni'], shape=params['cni_shape'])
cnp = readMap(params['global'] + params['cnp'], shape=params['cnp_shape'])
fname = os.listdir(params['indir'])[ID]
print("loading wavefront: {}".format(fname))
wfr = Wavefront()
wfr.load_hdf5(params['indir'] + fname)
pulseEnergy(wfr, esi, ID, mode='integrated')
pulseEnergy(wfr, esp, ID, mode='pulse')
print("Pulse Energy Calculated")
centroid(wfr, cni, ID, mode='integrated')
centroid(wfr, cnp, ID, mode='pulse')
print("Pulse Centroid Calculated")
### integrated beam profile
print("Calculating Integrated Beam Profiles")
BeamSize(wfr, mode="integrated", memMap=bsi, ID=ID)
print("Integrated Beam Profiles Calculated")
### pulsed beam profile
print("calculating pulsed beam profiles")
BeamSize(wfr, mode="pulse", memMap=bss, ID=ID, VERBOSE=True)
print("Beam Size Calculated")
def propagate_NVE():
wfr_directory = sys.argv[1].replace("*", "/")
job_name = "NKB_4980eV_250pC_Source_to_NVE"
python_command = propagate_NVE
input_directory = dCache + "/NanoKB-Pulse/source/"
save_directory = input_directory.replace("/source/", "/NVE/")
mkdir_p(save_directory)
log_directory = logs
focus = "nano"
analysis = False
filename = __file__
dt = datetime.now().__str__()
function = python_command.__name__
description = "Propagate NanoKB Pulses 4.98 keV, 250 pC from Undulator-exit to the NVE"
crop = 'NVE'
append = None
print("info")
print("wavefront directory: {}".format(wfr_directory))
print("save directory: {}".format(save_directory))
print("focus (i.e. beamline option): {}".format(focus))
print("analysis: {}".format(analysis))
print("datetime: {}".format(dt))
print("filename: {}".format(filename))
print("function: {}".format(function))
print("description: {}".format(description))
wfr = Wavefront()
wfr.load_hdf5(wfr_directory)
wfr.set_electric_field_representation('frequency')
wfr = scale(wfr)
print("wfr domain: {}".format(wfr.params.wDomain))
bl = get_beamline_object(ekev=4.96,
options=focus,
crop=crop,
theta_KB=5e-03,
theta_HOM=3.5e-03)
wfr.custom_fields['focus'] = focus
wfr.custom_fields['job name'] = job_name
wfr.custom_fields['input directory'] = wfr_directory
wfr.custom_fields['datetime'] = dt
wfr.custom_fields['function'] = function.__str__()
wfr.custom_fields['filename'] = filename
wfr.custom_fields['description'] = description
#wfr.custom_fields['bl'] = bl.__str__
bl.propagate(wfr)
if analysis:
wfr.analysis()
wfr.store_hdf5(wfr_directory.replace("/source/", "/NVE/"))
# -*- coding: utf-8 -*-
import sys
from felpy.model.wavefront import Wavefront
from felpy.model.beamline import Beamline
from wpg.optical_elements import Drift
from felpy.model.tools import propagation_parameters
from felpy.utils.os_utils import mkdir_p
if __name__ == '__main__':
print("working")
in_directory = sys.argv[1]
print("in: ", in_directory)
out_directory = sys.argv[2]
print("out: ", out_directory)
wfr = Wavefront()
wfr.load_hdf5(in_directory)
print("wfr loaded")
bl = Beamline()
bl.append(Drift(3.644 - 2.2),
propagation_parameters(1, 1, 1, 1, 'quadratic'))
bl.propagate(wfr)
print("wfr propagated")
wfr.store_hdf5(out_directory)
print("wfr stored")
wfr.analysis(VERBOSE=True, DEBUG=True)
#print(wfr.custom_fields) ## good debug
def testGeneratedPulses(indir, fname, n):
wfr = Wavefront()
wfr.load_hdf5(indir + fname + "_{}.h5".format(n))
def test():
wfr = constructPulse(nz=10)
zc = fitZernicke(wfr)
return zc
if __name__ == '__main__':
#ph, zc = test()
mode = 'integrated'
where = 'in' ## source or sample
fname = sys.argv[1]
outdir = "/gpfs/exfel/data/group/spb-sfx/user/guestt/h5/NanoKB-Pulse/data/zernike/"
savdir = outdir + mode + "/"
mkdir_p(outdir)
mkdir_p(savdir)
wfr = Wavefront()
wfr.load_hdf5(
"/gpfs/exfel/data/group/spb-sfx/user/guestt/h5/NanoKB-Pulse/{}/{}".
format(where, fname))
zc = fitZernicke(wfr, mode=mode, nterms=1250)
np.save(savdir + fname, zc)
Ps = wfr.get_phase(slice_number=0) #
Is = wfr.get_intensity(slice_number=0)
ekev = wfr.params.photonEnergy
z1 = 1
z2 = 1
pix_size = wfr.get_spatial_resolution()[0]
delta = 1
beta = 1
bg_val = 1
scale = 1
#######################################
wfr = Wavefront()
wfr.load_hdf5("coherentSrc.h5")
bl = Beamline()
bl.append(Drift(2), propagation_parameters(1, 1, 1, 1, mode='normal'))
bl.propagate(wfr)
Pr = wfr.get_phase(slice_number=0) #% np.pi*2
Ir = wfr.get_intensity(slice_number=0)
for I in [Ir, Is]:
I[np.where(I == 0)] = 1e-10
results = tiePavlov(Is, Ir, ekev, z1, z2, pix_size, delta, beta, bg_val,
scale) % np.pi * 2
phase = Ps - Pr
plt.imshow(phase)
src.store_hdf5("../data/tmp/source.h5")
except (KeyError):
os.remove("../data/tmp/source.h5")
src.store_hdf5("../data/tmp/source.h5")
src = Source()
src.load_hdf5("../data/tmp/source.h5")
from felpy.model.wavefront import Wavefront
from wpg.wpg_uti_wf import plot_intensity_map
wfr = Wavefront()
from felpy.model.beamline import Beamline
from wpg.optical_elements import Drift
from felpy.model.tools import propagation_parameters
from matplotlib import pyplot as plt
bl = Beamline()
bl.append(Drift(50), propagation_parameters(1, 1, 1, 1, mode='fresnel'))
for w in src.pulses:
wfr.load_hdf5(w)
bl.propagate(wfr)
plt.plot(wfr.x_axis,
wfr.get_x_profile(),
label="{} $\mu$ rad".format(wfr.source_properties['theta_x'] *
1e6))
#plot_intensity_map(wfr)
print(wfr.com)
plt.legend()
def loadWavefront(fname):
wfr = Wavefront()
wfr.load_hdf5(indir + fname)
return wfr