def fourier_reshape(vec):
vecFT = np.array(vec.shape, dtype=complex)
dvecFT = np.array(vec.shape, dtype=complex)
ddvecFT = np.array(vec.shape, dtype=complex)
dddvecFT = np.array(vec.shape, dtype=complex)
vecFT = FFT(vec)
freqs = FREQS(len(vec))
dvecFT = 1j * (freqs + .01j) * vecFT
ddvecFT = -1 * np.power(freqs + .01j, int(2)) * vecFT
dddvecFT = -1j * np.power(freqs + .01j, int(3)) * vecFT
dvec = np.real(IFFT(dvecFT)) / vec.shape[0]
ddvec = np.real(IFFT(ddvecFT)) / vec.shape[0]
dddvec = np.real(IFFT(dddvecFT)) / vec.shape[0]
return dvec, ddvec, dddvec
def split_operator(steps):
global psi
x_operator = np.exp(-0.5j * dt * V)
k_operator = np.exp(-0.5j * dt * (np.fft.fftfreq(n) *
(2 * np.pi / dx))**2 / m)
for i in range(steps):
psi = IFFT(FFT(psi * x_operator) * k_operator) * x_operator
def simulate_tof(nwaveforms=16,nelectrons=12,e_retardation=530,e_photon=600,printfiles=True):
collection = nparray([0,1,2],dtype=float)
s_collection_ft = nparray([0,1,2],dtype=complex)
n_collection_ft = nparray([0,1,2],dtype=complex)
if printfiles:
(s_collection_ft,n_collection_ft,f_extend,t_extend) = fillimpulseresponses(printfiles=printfiles)
else:
infilepath = '../data_fs/extern/'
(s_collection_ft,n_collection_ft,f_extend,t_extend) = readimpulseresponses(infilepath)
print(s_collection_ft.shape)
dt = t_extend[1]-t_extend[0]
#nwaveforms=10 # now a method input
for i in range(nwaveforms):
# this is for the incremental output as the collection is building
#nelectrons = int(16)
#e_retardation = 530 ## now a method input
nphotos = nelectrons//3
npistars = nelectrons//3
nsigstars = nelectrons//3
# d1-3 based on CookieBoxLayout_v2.3.dxf
d1 = 7.6/2.
d2 = 17.6/2.
d3 = 58.4/2.
d3 -= d2
d2 -= d1
evec = fillcollection(e_photon = e_photon,nphotos=nphotos,npistars=npistars,nsigstars=nsigstars)
sim_times = energy2time(evec,r=15.,d1=d1,d2=d2,d3=d3)
sim_times = append(sim_times,0.) # adds a prompt
s_collection_colinds = choice(s_collection_ft.shape[1],sim_times.shape[0])
n_collection_colinds = choice(n_collection_ft.shape[1],sim_times.shape[0])
v_simsum_ft = zeros(s_collection_ft.shape[0],dtype=complex)
for i,t in enumerate(sim_times):
#samplestring = 'enumerate sim_times returns\t%i\t%f' % (i,t)
#print(samplestring)
v_simsum_ft += s_collection_ft[:,s_collection_colinds[i]] * fourier_delay(f_extend,t)
v_simsum_ft += n_collection_ft[:,n_collection_colinds[i]]
v_simsum = real(IFFT(v_simsum_ft,axis=0))
if collection.shape[0] < v_simsum.shape[0]:
collection = t_extend
collection = column_stack((collection,v_simsum))
return collection
def simulate_cb(signal_ft,noise_ft,freqs,times,retardations,transmissions,intensity=1.,photonenergy=600.,angle=0.,amplitude=50.):
collection = nparray([0,1,2],dtype=float)
'''
Same as below for simulate_tof()
Just this time we are inputing the alread built collection_ft etc.
input also the angle of streaking and amplitude of streaking
imput also the retardations and transmissions as vectors
'''
angles = np.arange(retardations.shape[0])*2*pi/float(transmissions.shape[0])
nphotos = 50*gamma(transmissions*nppower(cos(angles),int(2))*intensity).astype(int)
npistars = 50*gamma(transmissions*intensity).astype(int)
nsigstars = 50*gamma(transmissions*intensity).astype(int)
for i in range(retardations.shape[0]):
evec = fillcollection(e_photon = photonenergy,nphotos=nphotos[i],npistars=npistars[i],nsigstars=nsigstars[i])
# d1-3 based on CookieBoxLayout_v2.3.dxf
d1 = 7.6/2.
d2 = 17.6/2.
d3 = 58.4/2.
d3 -= d2
d2 -= d1
sim_times = energy2time(evec,r=retardations[i],d1=d1,d2=d2,d3=d3)
sim_times = append(sim_times,0.) # adds a prompt
signal_colinds = choice(signal_ft.shape[1],sim_times.shape[0])
noise_colinds = choice(noise_ft.shape[1],sim_times.shape[0])
v_simsum_ft = zeros(signal_ft.shape[0],dtype=complex)
for i,t in enumerate(sim_times):
v_simsum_ft += signal_ft[:,signal_colinds[i]] * fourier_delay(freqs,t)
v_simsum_ft += noise_ft[:,noise_colinds[i]]
v_simsum = real(IFFT(v_simsum_ft,axis=0))
if collection.shape[0] < v_simsum.shape[0]:
collection = times
collection = column_stack((collection,v_simsum))
return collection
def back_transform(ft_abs, ft_arg):
return np.real(IFFT(nprect(ft_abs, ft_arg)))
with open(filename, 'w') as f:
f.writelines([str(s) + '\n' for s in signal])
def fillimpulseresponses(printfiles = True,samplefiles = False):
(s_collection_ft,n_collection_ft) = (nparray([0,0,0],dtype=complex),nparray([0,0,0],dtype=complex))
filepath = '../data_fs/ave1/'
filematch = filepath + 'C1--LowPulseHighRes-in-100-out1700-an2100--*.txt'
filelist = glob.glob(filematch)
print('filling impulse response files\n\tnum files = %i' % len(filelist))
for i,f in enumerate(filelist):
## processing images
## samplefiles = False
m = re.search('(.+).txt$',f)
if (i%10 == 0 and samplefiles):
outname_spect = m.group(1) + '.spect.dat'
outname_time = m.group(1) + '.time.dat'
outname_simTOF = m.group(1) + '.simTOF.dat'
fi = open(f, "r")
for passline in range(6):
headline = '# ' + fi.readline()
(t,v) = fi.readline().split()
v_vec=nparray(float(v),dtype=float)
t_vec=nparray(float(t)*1.e9,dtype=float)
for line in fi:
(t,v) = line.split()
v_vec = row_stack((v_vec,float(v)))
t_vec = row_stack((t_vec,float(t)*1.e9))
fi.close()
#Get the mean time-step for sake of frequencies
dt = mean(diff(t_vec,n=1,axis=0))
#FFT the vector
v_vec_ft = FFT(v_vec,axis=0)
f = FREQ(v_vec_ft.shape[0],dt)
m_extend = 10
f_extend = FREQ(v_vec_ft.shape[0]*m_extend,dt)
t_extend = arange(0,((t_vec[-1]-t_vec[0])+dt)*m_extend,dt)
# deep copy for the noise extimation
n_vec_ft = npcopy(v_vec_ft)
# find indices where there is only noise in the power, and indices with predominantly signal
# replace the signal elements in the noise vector with a random sampling from the noise portion
chooseinds = nparray([i for i,nu in enumerate(f) if (npabs(nu)> 6.5 and npabs(nu)<(20))])
replaceinds = nparray([i for i,nu in enumerate(f) if npabs(nu)< 6.5])
values = choice(n_vec_ft[chooseinds,0],len(replaceinds))
n_vec_ft[replaceinds,0] = values
## build noise vector and add to n_collection_ft
# sort inds for f and use for interp to extend noise in fourier domain
inds = argsort(f)
n_vec_extend_ft_r = interp(f_extend,f[inds],npabs(n_vec_ft[inds,0]))
n_vec_extend_ft_phi = choice(npangle(n_vec_ft[:,0]),f_extend.shape[0])
n_vec_extend_ft = nprect(n_vec_extend_ft_r,n_vec_extend_ft_phi)
n_vec_extend_ft.shape = (n_vec_extend_ft.shape[0],1)
if n_collection_ft.shape[0] < n_vec_extend_ft.shape[0]:
n_collection_ft = npcopy(n_vec_extend_ft)
# s_collection_ft.shape = (s_collection_ft.shape[0],1)
else:
n_collection_ft = column_stack((n_collection_ft,n_vec_extend_ft))
## build signal vector and add to n_collection_ft
noiseamp = nppower(mean(npabs(values)),int(2))
sigamp = nppower(mean(nparray([i for i,nu in enumerate(f) if npabs(nu)< 1.0])),int(2))
s_vec_ft = npcopy(v_vec_ft)
s_vec_ft[:,0] *= Weiner(f,sigamp,noiseamp,cut = 5,p = 4) * fourier_delay(f,-40) ## Weiner filter and dial back by 40 ns
if samplefiles:
out = column_stack((f,npabs(v_vec_ft),npabs(n_vec_ft),npabs(s_vec_ft)))
savetxt(outname_spect,out,fmt='%.4f')
s_vec = real(IFFT(s_vec_ft,axis=0))
s_vec_extend = zeros((f_extend.shape[0],1),dtype=float)
s_vec_extend[:s_vec.shape[0],0] = s_vec[:,0]
s_vec_extend_ft = FFT(s_vec_extend,axis=0)
if s_collection_ft.shape[0] < s_vec_extend_ft.shape[0]:
s_collection_ft = npcopy(s_vec_extend_ft)
# s_collection_ft.shape = (s_collection_ft.shape[0],1)
else:
s_collection_ft = column_stack((s_collection_ft,s_vec_extend_ft))
# first sum all the Weiner filtered and foureir_delay() signals, then add the single noise vector back
if printfiles:
outpath = '../data_fs/extern/'
filename = outpath + 'signal_collection_ft'
npsave(filename,s_collection_ft)
filename = outpath + 'noise_collection_ft'
npsave(filename,n_collection_ft)
filename = outpath + 'frequencies_collection'
npsave(filename,f_extend)
filename = outpath + 'times_collection'
npsave(filename,t_extend)
return (s_collection_ft,n_collection_ft,f_extend,t_extend)
def split_operator(steps):
global psi
for i in range(steps):
psi =IFFT(FFT(psi*x_operator)*k_operator)*x_operator
def back_transform(ft_abs, ft_arg):
return np.real(IFFT(nprect(ft_abs, ft_arg)))
for r in range(nrolls):
#roller[r,:] = np.roll(np.copy(lineout) , (r*len(lineout))//nrolls);
roller[r,:] = np.roll(np.copy(lineout), r*len(lineout)//nrolls);
lineoutFT = FFT(np.roll(lineout,len(lineout)//2) );
rollerFT = FFT(roller,axis=1);
#ft_abs = np.copy(np.abs(lineoutFT));
#ft_arg = np.copy(np.angle(lineoutFT));
ft_abs = np.copy(np.abs(rollerFT[1,:]));
ft_arg = np.copy(np.angle(rollerFT[1,:]));
dargs = np.diff( np.unwrap( np.angle( rollerFT ) , axis = 1 ), axis =1 );
#lineoutback = np.real( IFFT(nprect( w_weights, np.angle(rollerFT[0,:]) )) );
#lineoutback = np.real( IFFT(nprect(w_weights,ft_arg)) );
lineoutback = np.real( IFFT(nprect(ft_abs,ft_arg)) );
#lineoutback = np.real( IFFT(rollerFT[1,:]) );
R_back = np.row_stack((R_back,lineoutback));
avg = np.average(dargs[:,:nslopes],axis=1,weights = ft_abs[1:nslopes+1]);
avg.shape=(avg.shape[0],1);
eb_data = (ebResults.ebeamL3Energy() , ebResults.ebeamCharge(), ebResults.ebeamEnergyBC1(), ebResults.ebeamEnergyBC2(), ebResults.ebeamLTU250(), ebResults.ebeamLTU450(), ebResults.ebeamLTUAngX(), ebResults.ebeamLTUAngY(), ebResults.ebeamLTUPosX(), ebResults.ebeamLTUPosY(), ebResults.ebeamUndAngX(), ebResults.ebeamUndAngY(), ebResults.ebeamUndPosX(), ebResults.ebeamUndPosY(), ebResults.ebeamPkCurrBC1(), ebResults.ebeamEnergyBC1(), ebResults.ebeamPkCurrBC2(), ebResults.ebeamEnergyBC2(), ebResults.ebeamDumpCharge());
eb_data_hdr = 'ebResults.ebeamL3Energy()\tebResults.ebeamCharge()\tebResults.ebeamEnergyBC1()\tebResults.ebeamEnergyBC2()\tebResults.ebeamLTU250()\tebResults.ebeamLTU450()\tebResults.ebeamLTUAngX()\tebResults.ebeamLTUAngY()\tebResults.ebeamLTUPosX()\tebResults.ebeamLTUPosY()\tebResults.ebeamUndAngX()\tebResults.ebeamUndAngY()\tebResults.ebeamUndPosX()\tebResults.ebeamUndPosY()\tebResults.ebeamPkCurrBC1()\tebResults.ebeamEnergyBC1()\tebResults.ebeamPkCurrBC2()\tebResults.ebeamEnergyBC2()\tebResults.ebeamDumpCharge()';
gd_data_hdr = 'gdResults.f_11_ENRC()\tgdResults.f_12_ENRC()\tgdResults.f_21_ENRC()\tgdResults.f_22_ENRC()\tgdResults.f_63_ENRC()\tgdResults.f_64_ENRC()';
gd_data = ( gdResults.f_11_ENRC(), gdResults.f_12_ENRC(), gdResults.f_21_ENRC(), gdResults.f_22_ENRC(), gdResults.f_63_ENRC(), gdResults.f_64_ENRC() );
d_data_hdr = 'delay\ttimsChoice\tourChoice\trms\tdelay\tattenuation\tgd_11\t12\t21\t22\t63\t64'
d_data[0] = y_final*delayscales[i];
d_data[1] = timsChoice(avg,nrolls);
d_data[2],d_data[3] = ourChoice(dargs[:,:nslopes],ft_abs[1:nslopes+1]);
d_data[4] = slope2delay(d_data[2]);