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]);