def dxy(dtab, xytab, dout):
mytb = taskinit.tbtool()
os.system('cp -r ' + dtab + ' ' + dout)
# How many spws
mytb.open(dtab + '/SPECTRAL_WINDOW')
nspw = mytb.nrows()
mytb.close()
for ispw in range(nspw):
mytb.open(xytab)
st = mytb.query('SPECTRAL_WINDOW_ID==' + str(ispw))
x = st.getcol('CPARAM')
st.close()
mytb.close()
mytb.open(dout, nomodify=False)
st = mytb.query('SPECTRAL_WINDOW_ID==' + str(ispw))
d = st.getcol('CPARAM')
# the following assumes all antennas and chans same in both tables.
# Xinv.D.X:
d[0, :, :] *= pl.conj(x[0, :, :])
d[1, :, :] *= x[0, :, :]
st.putcol('CPARAM', d)
st.close()
mytb.close()
def dense_gauss_kernel(sigma, x, y=None):
xf = pylab.fft2(x) # x in Fourier domain
x_flat = x.flatten()
xx = pylab.dot(x_flat.transpose(), x_flat) # squared norm of x
if y is not None:
yf = pylab.fft2(y)
y_flat = y.flatten()
yy = pylab.dot(y_flat.transpose(), y_flat)
else:
yf = xf
yy = xx
xyf = pylab.multiply(xf, pylab.conj(yf))
xyf_ifft = pylab.ifft2(xyf)
row_shift, col_shift = pylab.floor(pylab.array(x.shape) / 2).astype(int)
xy_complex = pylab.roll(xyf_ifft, row_shift, axis=0)
xy_complex = pylab.roll(xy_complex, col_shift, axis=1)
xy = pylab.real(xy_complex)
scaling = -1 / (sigma**2)
xx_yy = xx + yy
xx_yy_2xy = xx_yy - 2 * xy
k = pylab.exp(scaling * pylab.maximum(0, xx_yy_2xy / x.size))
return k
def dxy(dtab,xytab,dout):
mytb=taskinit.tbtool()
os.system('cp -r '+dtab+' '+dout)
# How many spws
mytb.open(dtab+'/SPECTRAL_WINDOW')
nspw=mytb.nrows()
mytb.close()
for ispw in range(nspw):
mytb.open(xytab)
st=mytb.query('SPECTRAL_WINDOW_ID=='+str(ispw))
x=st.getcol('CPARAM')
st.close()
mytb.close()
mytb.open(dout,nomodify=False)
st=mytb.query('SPECTRAL_WINDOW_ID=='+str(ispw))
d=st.getcol('CPARAM')
# the following assumes all antennas and chans same in both tables.
# Xinv.D.X:
d[0,:,:]*=pl.conj(x[0,:,:])
d[1,:,:]*=x[0,:,:]
st.putcol('CPARAM',d)
st.close()
mytb.close()
def pwcausalr(x,Nr,Nl,porder,fs,freq=0): # Note: freq determines whether the frequency points are calculated or chosen
from pylab import size, shape, real, log, conj, zeros, arange, disp, array
from numpy import linalg; det=linalg.det
import numpy as np # Just for "sum"; can't remember what's wrong with pylab's sum
[L,N] = shape(x); #L is the number of channels, N is the total points in every channel
if freq==0: F=timefreq(x[0,:],fs) # Define the frequency points
else: F=array(range(0,freq+1)) # Or just pick them
npts=size(F,0)
# Initialize arrays
maxindex=np.sum(arange(1,L))
pp=zeros((L,npts))
# Had these all defined on one line, and stupidly they STAY linked!!
cohe=zeros((maxindex,npts))
Fy2x=zeros((maxindex,npts))
Fx2y=zeros((maxindex,npts))
Fxy=zeros((maxindex,npts))
index = 0;
for i in range(1,L):
for j in range(i+1,L+1):
y=zeros((2,N)) # Initialize y
index = index + 1;
y[0,:] = x[i-1,:];
y[1,:] = x[j-1,:];
A2,Z2,tmp = armorf(y,Nr,Nl,porder); #fitting a model on every possible pair
eyx = Z2[1,1] - Z2[0,1]**2/Z2[0,0]; #corrected covariance
exy = Z2[0,0] - Z2[1,0]**2/Z2[1,1];
f_ind = 0;
for f in F:
f_ind = f_ind + 1;
S2,H2 = spectrum_AR(A2,Z2,porder,f,fs);
pp[i-1,f_ind-1] = abs(S2[0,0]*2); # revised
if (i==L-1) & (j==L):
pp[j-1,f_ind-1] = abs(S2[1,1]*2); # revised
cohe[index-1,f_ind-1] = real(abs(S2[0,1])**2 / S2[0,0]/S2[1,1]);
Fy2x[index-1,f_ind-1] = log(abs(S2[0,0])/abs(S2[0,0]-(H2[0,1]*eyx*conj(H2[0,1]))/fs)); #Geweke's original measure
Fx2y[index-1,f_ind-1] = log(abs(S2[1,1])/abs(S2[1,1]-(H2[1,0]*exy*conj(H2[1,0]))/fs));
Fxy[index-1,f_ind-1] = log(abs(S2[0,0]-(H2[0,1]*eyx*conj(H2[0,1]))/fs)*abs(S2[1,1]-(H2[1,0]*exy*conj(H2[1,0]))/fs)/abs(det(S2)));
return F,pp,cohe,Fx2y,Fy2x,Fxy
def dense_gauss_kernel(sigma, x, y=None):
"""
Gaussian Kernel with dense sampling.
Evaluates a gaussian kernel with bandwidth SIGMA for all displacements
between input images X and Y, which must both be MxN. They must also
be periodic (ie., pre-processed with a cosine window). The result is
an MxN map of responses.
If X and Y are the same, omit the third parameter to re-use some
values, which is faster.
"""
xf = pylab.fft2(x) # x in Fourier domain
x_flat = x.flatten()
xx = pylab.dot(x_flat.transpose(), x_flat) # squared norm of x
if y is not None:
# general case, x and y are different
yf = pylab.fft2(y)
y_flat = y.flatten()
yy = pylab.dot(y_flat.transpose(), y_flat)
else:
# auto-correlation of x, avoid repeating a few operations
yf = xf
yy = xx
# cross-correlation term in Fourier domain
xyf = pylab.multiply(xf, pylab.conj(yf))
# to spatial domain
xyf_ifft = pylab.ifft2(xyf)
#xy_complex = circshift(xyf_ifft, floor(x.shape/2))
row_shift, col_shift = pylab.floor(pylab.array(x.shape) / 2).astype(int)
xy_complex = pylab.roll(xyf_ifft, row_shift, axis=0)
xy_complex = pylab.roll(xy_complex, col_shift, axis=1)
xy = pylab.real(xy_complex)
# calculate gaussian response for all positions
scaling = -1 / (sigma**2)
xx_yy = xx + yy
xx_yy_2xy = xx_yy - 2 * xy
k = pylab.exp(scaling * pylab.maximum(0, xx_yy_2xy / x.size))
#print("dense_gauss_kernel x.shape ==", x.shape)
#print("dense_gauss_kernel k.shape ==", k.shape)
return k
def dense_gauss_kernel(sigma, x, y=None):
"""
Gaussian Kernel with dense sampling.
Evaluates a gaussian kernel with bandwidth SIGMA for all displacements
between input images X and Y, which must both be MxN. They must also
be periodic (ie., pre-processed with a cosine window). The result is
an MxN map of responses.
If X and Y are the same, ommit the third parameter to re-use some
values, which is faster.
"""
xf = pylab.fft2(x) # x in Fourier domain
x_flat = x.flatten()
xx = pylab.dot(x_flat.transpose(), x_flat) # squared norm of x
if y is not None:
# general case, x and y are different
yf = pylab.fft2(y)
y_flat = y.flatten()
yy = pylab.dot(y_flat.transpose(), y_flat)
else:
# auto-correlation of x, avoid repeating a few operations
yf = xf
yy = xx
# cross-correlation term in Fourier domain
xyf = pylab.multiply(xf, pylab.conj(yf))
# to spatial domain
xyf_ifft = pylab.ifft2(xyf)
#xy_complex = circshift(xyf_ifft, floor(x.shape/2))
row_shift, col_shift = pylab.floor(pylab.array(x.shape)/2).astype(int)
xy_complex = pylab.roll(xyf_ifft, row_shift, axis=0)
xy_complex = pylab.roll(xy_complex, col_shift, axis=1)
xy = pylab.real(xy_complex)
# calculate gaussian response for all positions
scaling = -1 / (sigma**2)
xx_yy = xx + yy
xx_yy_2xy = xx_yy - 2 * xy
k = pylab.exp(scaling * pylab.maximum(0, xx_yy_2xy / x.size))
#print("dense_gauss_kernel x.shape ==", x.shape)
#print("dense_gauss_kernel k.shape ==", k.shape)
return k
def dense_gauss_kernel(sigma, x, y=None):
"""
通过高斯核计算余弦子窗口图像块的响应图
利用带宽是 sigma 的高斯核估计两个图像块 X (MxN) 和 Y (MxN) 的关系。X, Y 是循环的、经余弦窗处理的。输出结果是
响应图矩阵 MxN. 如果 X = Y, 则函数调用时取消 y，则加快计算。
该函数对应原文中的公式 (16)，以及算法1中的 function k = dgk(x1, x2, sigma)
:param sigma: 高斯核带宽
:param x: 余弦子窗口图像块
:param y: 空或者模板图像块
:return: 响应图
"""
# 计算图像块 x 的傅里叶变换
xf = pylab.fft2(x) # x in Fourier domain
# 把图像块 x 拉平
x_flat = x.flatten()
# 计算 x 的2范数平方
xx = pylab.dot(x_flat.transpose(), x_flat) # squared norm of x
if y is not None:
# 一半情况， x 和 y 是不同的，计算 y 的傅里叶变化和2范数平方
yf = pylab.fft2(y)
y_flat = y.flatten()
yy = pylab.dot(y_flat.transpose(), y_flat)
else:
# x 的自相关，避免重复计算
yf = xf
yy = xx
# 傅里叶域的互相关计算，逐元素相乘
xyf = pylab.multiply(xf, pylab.conj(yf))
# 转化为频率域
xyf_ifft = pylab.ifft2(xyf)
# 对频率域里的矩阵块进行滚动平移，分别沿 row 和 col 轴
row_shift, col_shift = pylab.floor(pylab.array(x.shape) / 2).astype(int)
xy_complex = pylab.roll(xyf_ifft, row_shift, axis=0)
xy_complex = pylab.roll(xy_complex, col_shift, axis=1)
xy = pylab.real(xy_complex)
# 计算高斯核响应图
scaling = -1 / (sigma**2)
xx_yy = xx + yy
xx_yy_2xy = xx_yy - 2 * xy
return pylab.exp(scaling * pylab.maximum(0, xx_yy_2xy / x.size))
def myfft_gc_skew(x, M=1000):
"""
x : GC_skew vector (list)
param N: length of the GC skew vector
param M: length of the template
param A: amplitude between positive and negative GC skew vector
"""
N = len(x)
template = get_template(M) + [0] * (N - M)
template /= pylab.norm(template)
c = abs(np.fft.ifft(np.fft.fft(x) * pylab.conj(np.fft.fft(template)))**
2) / pylab.norm(x) / pylab.norm(template)
# shift the SNR vector by the template length so that the peak is at the END of the template
c = np.roll(c, M // 2)
return x, template, c * 2. / N
def detrend(data,detrend_Kernel_Length = 10,sampling_Frequency = 100000,channels = 8):
from pylab import fft, ifft, sin , cos,log,plot,show,conj,legend
import random
n=len(data[0])
detrend_fft_Length = (2**((log(detrend_Kernel_Length * sampling_Frequency)/log(2))))
ma = [1.0]*sampling_Frequency
ma.extend([0.0]*(detrend_fft_Length - sampling_Frequency))
mafft = fft(ma)
trend = [0.0]*n
for nch in range(channels):
count = 0
while count + detrend_fft_Length <= len(data[nch]):
temp = data[nch][count:count+int(detrend_fft_Length)]
y = fft(temp)
z = ifft( conj(mafft)*y)
for cc in xrange(count,count+(int(detrend_fft_Length)-sampling_Frequency)):
trend[cc] = z[cc-count].real / sampling_Frequency
count = count+(int(detrend_fft_Length)-sampling_Frequency)
for cc in xrange(len(trend)):
data[nch][cc] = data[nch][cc] - trend[cc]
def myfft(N=100000, M=1000, A=0.05, dispersion=0.01):
"""
param N: length of the GC skew vector
param M: length of the template
param A: amplitude between positive and negative GC skew vector
"""
N = int(N / 2)
x1 = [A + (random.random() - 0.5) * dispersion for i in range(N)]
x2 = [-A + (random.random() - 0.5) * dispersion for i in range(N)]
x = x1 + x2
x = x[int(N / 4):] + x[0:int(N / 4)]
template = get_template(M) + [0] * (N * 2 - M)
template /= norm(template)
c = abs(fft.ifft(fft.fft(x) * conj(fft.fft(template)))**
2) / norm(x) / norm(template)
# shift the SNR vector by the template length so that the peak is at the END of the template
c = np.roll(c, M // 2)
return x, template, c * 2. / N
def __init__(self,model,lam,nIn=1.,nOut=1.,thetaIn=0,pol='Ey',interpolationType='materialBased',
nInName="top interface",nOutName="bottom interface"):
M = model
self.M = M
self.lam = lam
self.nIn = nIn
self.nOut = nOut
self.thetaIn = thetaIn
self.pol = pol
self.interpolationType = interpolationType
self.materials = [self.nIn,self.nOut]
self.materialNames = [nInName,nOutName]
if self.nIn.imag != 0:
warnings.warn("Input refractive index HAS to be real! Expect wrong results.",Warning)
if self.nOut.imag != 0:
pass
#warnings.warn("Warning, it is not thorougly tested if a complex epsOut works",Warning)
#Seems to work.. but I guess transmission parameters make little meaning
#####################
##Derived parameters
#####################
self.k0 = 2*pi/self.lam #Wave number
self.freq = self.k0/(2*pi) #Frequency
self.epsIn = self.nIn**2
self.epsOut = self.nOut**2
self.kIn = self.nIn*self.k0 #Wavenumber for top material
self.kOut = self.nOut*self.k0 #Wavenumber for bottom material
wavefrac = self.lam/(M.elmsize*max(self.nIn,self.nOut))
if wavefrac < 10:
warnings.warn("You are using less than 10 elm per wavelength (may be okay"+
"for highly absorptive/reflective materials",Warning)
if wavefrac < 6:
warnings.warn("SERIOUSLY?? You are using less than 6 elm per wavelength (may be okay"+
"for highly absorptive/reflective materials",Warning)
self.kInx = self.kIn*sin(self.thetaIn) #Inc wave vector component
self.kInz = self.kIn*cos(self.thetaIn) # -||-
##################################
#Precalculated sizes for FE solver
##################################
self.alpha0 = self.kInx
self.alpha = pl.zeros(M.NM)
#print "Det ser ud til at chi er defineret forkert i Diaz vs Dossou (den skal ikke konjugeres)"
self.chiIn = pl.zeros(M.NM,dtype='complex')
self.chiOut = pl.zeros(M.NM,dtype='complex')
for m in range(-M.Nm,M.Nm+1):
idx = m+M.Nm
self.alpha[idx] = self.alpha0+2*pi*m/M.lx
self.chiIn[idx] = pl.conj(sqrt(0.j+self.kIn**2-self.alpha[idx]**2))
self.chiOut[idx] = pl.conj(sqrt(0.j+self.kOut**2-self.alpha[idx]**2))
self.thetaModesIn = pl.arcsin(0.j+self.alpha/self.kIn)
self.thetaModesOut = pl.arcsin(0.j+self.alpha/self.kOut)
self.propModesIn = abs(self.thetaModesIn.imag) < 1e-8 #Slice of incoming propagating modes
self.propModesOut = abs(self.thetaModesOut.imag) < 1e-8 #Slice of outgoing propagating modes
import pylab as pl
# plot the magnitude of the amplification factor for CTCS for k Dx = pi/2
# a range of values of c
c = pl.linspace(-1.5,1.5,31)
# two roots of the amplification factor (1j = sqrt(-1) = complex(0,1))
A1 = -1j*c + pl.sqrt(complex(1,0)-c**2)
A2 = -1j*c - pl.sqrt(complex(1,0)-c**2)
# the magnitude squared of each of the amplification factors
mag2A1 = A1*pl.conj(A1)
mag2A2 = A2*pl.conj(A2)
# plot the squared magnitudes
pl.ion()
pl.clf()
font = {'size' : 24}
pl.rc('font', **font)
pl.grid(True, which='both')
pl.plot(c, mag2A1, 'b', label='positive root')
pl.plot(c, mag2A2, 'r', label='negative root')
pl.legend(loc='best')
pl.xlabel('Courant number, $c$')
pl.ylabel('$||A||^2$')
pl.savefig('CTCSA.pdf')
def TFE(x,y):
from pylab import fft,zeros,arange,cos,pi,conj,log,plot,show
#we just need cross-spectral Pxy
## Fill in defaults for arguments that aren't specified
Fs = 2
overlap = .5
seg_size =2 ** int( log((len(x)/(1-overlap))**.5)*1/log(2) +.5)
#hanning window is H = .5*(1 - cos(2*pi*(0:n-1)'/(n-1)))
#lets compute this infunctions
overlap = seg_size*.5
#window = [.5*(1 - cos(2*pi*(n)/(seg_size-1))) for n in xrange(seg_size)]
window = [0.54 - 0.46 * cos( (2*pi/seg_size) * k) for k in range(0,seg_size)]
step = seg_size - overlap
nfft = max(256, len(window))
Pxx = [complex(0,0)]*(64)
Pxy = [complex(0,0)]*(64)
avg = sum(x)/len(x)
x = [xx-avg for xx in x]
avg = sum(y)/len(y)
y = [yy-avg for yy in y]
## Average the slices
l=64
offset = arange(0,len(x)-overlap,step)
N = len(offset)
for i in xrange(0,N):
A=x[int(offset[i]):int(offset[i]+seg_size)]
print seg_size
A=[A[j]*window[j] for j in xrange(seg_size)]
#A.extend([0.0]*(len(window)-nfft))
A = fft(A,l)
for j in xrange(seg_size):
temp = A[j]*conj(A[j])
Pxx[j]=Pxx[j].real+temp.real
B=y[int(offset[i]):int(offset[i]+seg_size)]
B=[B[j]*window[j] for j in xrange(seg_size)]
#B.extend([0.0]*(len(window)-nfft))
B = fft(B,l)
#P = [A[i]*conj(B[i]) for i in xrange(len(A))]
for j in range(seg_size):
temp = A[j]*conj(B[j])
Pxy[j]=complex(Pxy[j].real+ temp.real ,Pxy[j].imag-temp.imag)
#print sum(Pxy)
#plot(Pxy)
#plot(Pxx)
#show()
#print Pxx
#t = 0
#for t in range(len(Pxx)):
# t= t+int(Pxx[t] == 0.0)
#
#if t:print t,offset[i],offset[i]+step,i
P = [Pxy[j]/Pxx[j] for j in xrange(len(Pxx))] ;
P = P[0:nfft/2]
#print nfft,Fs
f = arange(0.0,2.0,float(Fs)/(nfft/4))
return f,P
avgwf3.MakeSimilarTo(rawwf)
if wf4count == 0 and channel == OPPI4ChannelNumber:
avgwf4.MakeSimilarTo(rawwf)
if goodOPPI3Waveform:
rawwf.MakeSimilarTo(avgwf3)
avgwf3 += rawwf
# Sample baseline from baseline window
a3base = numpy.ndarray(
int(baselineAverageTime / sampling_period), dtype="float", buffer=rawwf.GetData()
)
a3base = a3base / a3base.max()
if wf3count == 0:
a3bFFT = pylab.rfft(a3base)
else:
a3bFFT += pylab.rfft(a3base)
print a3bFFT * pylab.conj(a3bFFT)
raw_input("Press Enter to continue")
pylab.subplot(2, 1, 1)
X3 = numpy.arange(0, numpy.size(a3bFFT))
pylab.plot(X3, sampling_period * sampling_period * a3bFFT * pylab.conj(a3bFFT), label="OPPI3")
pylab.subplot(2, 1, 2)
pylab.psd(a3base, Fs=100e6)
fig.canvas.draw()
# pylab.plot(X3,a3bFFT,label='OPPI3')
# print "OPPI3 ", eventTime , avgwf3.GetLength(), a3.size , a3
wf3count += 1
if goodOPPI4Waveform:
rawwf.MakeSimilarTo(avgwf4)
avgwf4 += rawwf
# Sample baseline from baseline window
a4base = numpy.ndarray(
