#numero de amostras
a=np.unique(dd.ens)[:-2]
dd1 = {}
epr = {}
evx = {}
evy = {}
evz = {}
#separa os dados e calcula os espectros
for v in range(len(a)): #varia as horas de cada dia
dd1[str(v)] = dd.ix[pl.find(dd.ens == a[v]),:]
nfft = int(dd1[str(v)].shape[0] / 2)
epr[str(v)] = espec.espec1(dd1[str(v)].pr,nfft,fs)
evx[str(v)] = espec.espec1(dd1[str(v)].vx,nfft,fs)
evy[str(v)] = espec.espec1(dd1[str(v)].vy,nfft,fs)
evz[str(v)] = espec.espec1(dd1[str(v)].vz,nfft,fs)
pl.figure(figsize=(16,10))
cont = 0
for i in range(0,len(a),1):
print(i)
cont += 2
pl.subplot(1,4,1)
pl.semilogy(epr[str(i)][:,0],cont+epr[str(i)][:,1])
pl.xlim(0,0.2), pl.ylim(0,45)
pl.xlabel('Frequency (Hz)')
pl.ylabel('Spectral Density (m^2/Hz)')
pl.title('Pressure', fontname="Times New Roman Bold")
pr, vx, vy, vz = dd[:, [14, 2, 3, 4]].T
eta = np.concatenate((eta, vz), axis=1)
#processamento no dominio do tempo
hs, h10, hmax, tmed, thmax = proconda.ondat(t, vz, h)
#processamento no dominio da frequencia
#hm0_pr, tp_pr, dp_pr, sigma1, sigma2, sigma1p, sigma2p, freq, df, k, sn_pr, snx,sny, snn, snnx, snny, snxny, snxnx, snyny, a1, b1, a2, b2, dire1_pr, dire2 = proconda.ondaf(
#pr,vx,vy,h,nfft,fs) ##pressao
hm0, tp, dp, sigma1, sigma2, sigma1p, sigma2p, freq, df, k, sn, snx, sny, snn, snnx, snny, snxny, snxnx, snyny, a1, b1, a2, b2, dire1, dire2 = proconda.ondaf(
vz, vx, vy, h, nfft, fs)
#calcula os espectros de pr, vz, vx e vy
apr = espec.espec1(pr, nfft, fs)
avz = espec.espec1(vz, nfft, fs)
avx = espec.espec1(vx, nfft, fs)
avy = espec.espec1(vy, nfft, fs)
#corrige a declinacao magnetica
dp = dp - 23
dire1 = dire1 - 23
dire2 = dire2 - 23
#calcula o espectro de fase (fase e coerencia)
#acha o indice da fp
indfp = pl.find(sn[:, 0] == sn[sn[:, 1] == max(sn[:, 1]), 0])
fase_nnx.append(np.real(snnx[indfp, 4])[0]) #fase de heave e dspx
fase_nny.append(np.real(snny[indfp, 4])[0]) #fase de heave e dspx
def ondaf(eta,etax,etay,h,nfft,fs): """ #======================================================================# Calcula parametros de onda no dominio da frequencia Dados de entrada: eta - vetor de elevacao etax - vetor de deslocamento em x etay - vetor de deslocamento em y h - profundidade nfft - Numero de pontos utilizado para o calculo da FFT fs - frequencia de amostragem Dados de saida: pondaf = [hm0 tp dp] #======================================================================# """ #espectro simples sn = espec.espec1(eta,nfft,fs) snx = espec.espec1(etax,nfft,fs) sny = espec.espec1(etay,nfft,fs) #espectros cruzados snn = espec.espec2(eta,eta,nfft,fs) snnx = espec.espec2(eta,etax,nfft,fs) snny = espec.espec2(eta,etay,nfft,fs) snxny = espec.espec2(etax,etay,nfft,fs) snxnx = espec.espec2(etax,etax,nfft,fs) snyny = espec.espec2(etay,etay,nfft,fs) #vetor de frequencia f = sn[:,0] #deltaf df = f[1] - f[0] #calculo do numero de onda k = numeronda(h,f,len(f)) k = np.array(k) #calculo dos coeficientes de fourier - NDBC 96_01 e Steele (1992) c = snx[:,1] + sny[:,1] cc = np.sqrt(sn[:,1] * (c)) a1 = snnx[:,3] / cc b1 = snny[:,3] / cc a2 = (snx[:,1] - sny[:,1]) / c b2 = 2 * snxny[:,2] / c #calcula direcao de onda #mean direction dire1 = np.array([np.angle(np.complex(b1[i],a1[i]),deg=True) for i in range(len(a1))]) #principal direction dire2 = 0.5 * np.array([np.angle(np.complex(b2[i],a2[i]),deg=True) for i in range(len(a2))]) #condicao para valores maiores que 360 e menores que 0 dire1[np.where(dire1 < 0)] = dire1[np.where(dire1 < 0)] + 360 dire1[np.where(dire1 > 360)] = dire1[np.where(dire1 > 360)] - 360 dire2[np.where(dire2 < 0)] = dire2[np.where(dire2 < 0)] + 360 dire2[np.where(dire2 > 360)] = dire2[np.where(dire2 > 360)] - 360 #acha o indice da frequencia de pico ind = np.where(sn[:,1] == np.max(sn[:,1]))[0] #periodo de pico tp = (1. / f[ind])[0] #momento espectral de ordem zero total - m0 m0 = np.sum(sn[:,1]) * df #calculo da altura significativa hm0 = 4.01 * np.sqrt(m0) #direcao do periodo de pico dp = dire1[ind][0] #Espalhamento direcional #Formula do sigma1 do livro Tucker&Pitt(2001) "Waves in Ocean Engineering" pags 196-198 c1 = np.sqrt(a1 ** 2 + b1 **2) c2 = np.sqrt(a2 ** 2 + b2 ** 2) s1 = c1 / (1-c1) s2 = (1 + 3 * c2 + np.sqrt(1 + 14 * c2 + c2 ** 2)) / (2 * (1 - c2)) sigma1 = np.sqrt(2 - 2 * c1) * 180 / np.pi sigma2 = np.sqrt((1 - c2) / 2) * 180 / np.pi sigma1p = np.real(sigma1[ind])[0] sigma2p = np.real(sigma2[ind])[0] # pondaf = np.array([hm0, tp, dp, sigma1p, sigma2p]) return hm0, tp, dp, sigma1, sigma2, sigma1p, sigma2p, f, df, k, sn, snx, sny, snn, snnx, snny, snxny, snxnx, snyny, a1, b1, a2, b2, dire1, dire2
#hora = ['1400','1430','1500','1530','1600','1630','1700','1730','1800','1830','1900','1930','2000','2030','2100','2130','2200','2230','2300','2330','0000','0030','0100','0130','0200','0230','0300','0330','0400','0430','0500','0530','0600','0630','0700','0730','0800','0830','0900','0930','1000'][:-9]#41
#hora = ['0800','0845','0930','1015','1100','1145','1230','1315','1400','1445','1530','1615','1700','1745','1830','1915','2000','2045'][2:-3]
#hora = ['0730','0800','0830','0900','0930','1000','1030','1100','1130','1200','1230','1300','1330','1400','1430','1500','1530','1600','1630','1700','1730','1800','1830','1900','1930','2000','2030','2100','2130'][1:-4]
#hora = ['0730','0745','0800','0815','0830','0845','0900','0915','0930','0945','1000','1015','1030','1045','1100','1115','1130','1145','1200','1215','1230','1245','1300','1315','1330','1345','1400','1415','1430','1445','1500','1515','1530','1545','1600','1615','1630','1645','1700','1715','1730','1745','1800','1815'][4:-6]
#hora = (len(dd))
dd1 = {}
epr = {}
evx = {}
evy = {}
evz = {}
#separa os dados e calcula os espectros
for i in range(len(a)):
dd1[hora[i]] = dd.ix[pl.find(dd.ens == a[i]), :]
epr[hora[i]] = espec.espec1(dd1[hora[i]].pr, nfft, fs)
evx[hora[i]] = espec.espec1(dd1[hora[i]].vx, nfft, fs)
evy[hora[i]] = espec.espec1(dd1[hora[i]].vy, nfft, fs)
evz[hora[i]] = espec.espec1(dd1[hora[i]].vz, nfft, fs)
pl.figure()
cont = 0
for i in range(0, len(a), 1):
cont += 1
pl.subplot(1, 4, 1)
pl.plot(epr[hora[i]][:, 0], cont + epr[hora[i]][:, 1])
pl.xlim(0, 0.2), pl.ylim(0, 15)
pl.xlabel('Frequency (Hz)')
pl.ylabel('Spectral Density (m2/Hz')
pl.title('Pressure')
# a wavelet sera gerada com as regras acima
# serao calculadas as energias em cada faixa mencionada a partir do
# espectro de uma dimensao considerando que o espalhamento entre cada
# frequencia seja de 1/T
#calculo do espectro de uma dimensao
ww55 = zeros((10,1))
han = 1 #aplicacao da janela: han = 1 hanning ; han = 0 retangular
gl = 32
qq1 = espec.espec1(co,nfft,fs)
f1 = qq1[:,0]
qq1 = qq1[:,1] #auto-espectro
#faixas em segundos
#2 3 4
#4 6 7.2
#7.14 8 10.8
#10.3 16 20.0
#intervalo de frequencia
df = f1[1] - f1[0]
#onda significativa (coloca a altura na primeira linha de ww5)
def ondaf(eta, etax, etay, h, nfft, fs):
"""
#======================================================================#
Calcula parametros de onda no dominio da frequencia
Dados de entrada: eta - vetor de elevacao
etax - vetor de deslocamento em x
etay - vetor de deslocamento em y
h - profundidade
nfft - Numero de pontos utilizado para o calculo da FFT
fs - frequencia de amostragem
Dados de saida: pondaf = [hm0 tp dp]
#======================================================================#
"""
#espectro simples
sn = espec.espec1(eta, nfft, fs)
snx = espec.espec1(etax, nfft, fs)
sny = espec.espec1(etay, nfft, fs)
#espectros cruzados
snn = espec.espec2(eta, eta, nfft, fs)
snnx = espec.espec2(eta, etax, nfft, fs)
snny = espec.espec2(eta, etay, nfft, fs)
snxny = espec.espec2(etax, etay, nfft, fs)
snxnx = espec.espec2(etax, etax, nfft, fs)
snyny = espec.espec2(etay, etay, nfft, fs)
#vetor de frequencia
f = sn[:, 0]
#deltaf
df = f[1] - f[0]
#calculo do numero de onda
k = numeronda(h, f, len(f))
k = np.array(k)
#calculo dos coeficientes de fourier - NDBC 96_01 e Steele (1992)
c = snx[:, 1] + sny[:, 1]
cc = np.sqrt(sn[:, 1] * (c))
a1 = snnx[:, 3] / cc
b1 = snny[:, 3] / cc
a2 = (snx[:, 1] - sny[:, 1]) / c
b2 = 2 * snxny[:, 2] / c
#calcula direcao de onda
#mean direction
dire1 = np.array(
[np.angle(np.complex(b1[i], a1[i]), deg=True) for i in range(len(a1))])
#principal direction
dire2 = 0.5 * np.array(
[np.angle(np.complex(b2[i], a2[i]), deg=True) for i in range(len(a2))])
#condicao para valores maiores que 360 e menores que 0
dire1[np.where(dire1 < 0)] = dire1[np.where(dire1 < 0)] + 360
dire1[np.where(dire1 > 360)] = dire1[np.where(dire1 > 360)] - 360
dire2[np.where(dire2 < 0)] = dire2[np.where(dire2 < 0)] + 360
dire2[np.where(dire2 > 360)] = dire2[np.where(dire2 > 360)] - 360
#acha o indice da frequencia de pico
ind = np.where(sn[:, 1] == np.max(sn[:, 1]))[0]
#periodo de pico
tp = (1. / f[ind])[0]
#momento espectral de ordem zero total - m0
m0 = np.sum(sn[:, 1]) * df
#calculo da altura significativa
hm0 = 4.01 * np.sqrt(m0)
#direcao do periodo de pico
dp = dire1[ind][0]
#Espalhamento direcional
#Formula do sigma1 do livro Tucker&Pitt(2001) "Waves in Ocean Engineering" pags 196-198
c1 = np.sqrt(a1**2 + b1**2)
c2 = np.sqrt(a2**2 + b2**2)
s1 = c1 / (1 - c1)
s2 = (1 + 3 * c2 + np.sqrt(1 + 14 * c2 + c2**2)) / (2 * (1 - c2))
sigma1 = np.sqrt(2 - 2 * c1) * 180 / np.pi
sigma2 = np.sqrt((1 - c2) / 2) * 180 / np.pi
sigma1p = np.real(sigma1[ind])[0]
sigma2p = np.real(sigma2[ind])[0]
# pondaf = np.array([hm0, tp, dp, sigma1p, sigma2p])
return hm0, tp, dp, sigma1, sigma2, sigma1p, sigma2p, f, df, k, sn, snx, sny, snn, snnx, snny, snxny, snxnx, snyny, a1, b1, a2, b2, dire1, dire2
#parameters for spectral calculation depth = di['pres'][:,i].mean() + 0.9 nfft = len(di['pres']) / dft fs = 2 #sample freq #calcula parametros de ondas hm0, tp, dp, sigma1, sigma2, sigma1p, sigma2p, freq, df, k, sn, snx,sny, snn, snnx, snny, snxny, snxnx, snyny, a1, b1, a2, b2, dire1, dire2 = proconda.ondaf( di['vzu'][:,i],di['vxe'][:,i],di['vyn'][:,i],depth,nfft,fs) #concatena os parametros de onda aux_hm0.append(hm0) aux_tp.append(tp) aux_dp.append(dp) #concatena os espectros aux_esp_pr.append(espec.espec1(di['pres'][:,i], nfft, fs)[:,1]) aux_esp_vx.append(espec.espec1(di['vxe'][:,i], nfft, fs)[:,1]) aux_esp_vy.append(espec.espec1(di['vyn'][:,i], nfft, fs)[:,1]) aux_esp_vz.append(espec.espec1(di['vzu'][:,i], nfft, fs)[:,1]) #cria array com os parametros e espectros concatenados hm0 = np.array(aux_hm0) tp = np.array(aux_tp) dp = np.array(aux_dp) esp_pr = np.array(aux_esp_pr).T esp_vx = np.array(aux_esp_vx).T esp_vy = np.array(aux_esp_vy).T esp_vz = np.array(aux_esp_vz).T ##################################################
def daat1(pathname,listap,nfft,fs,ncol,p0,p1):
tic = time.clock()
dire = np.zeros((10,ncol)) #direcao (2 valores, ate 5 faixas)
espe = np.zeros((10,ncol)) #espectros (2 valores, ate 5 faixas)
energ = np.zeros((10,ncol)) #Hs + 5 energias (uma por faixa), 4 picos (maiores)
dire1 = np.copy(dire)
espe1 = np.copy(espe)
#tabela de senos e cossenos para o metodo da maxima entropia
#cria variaveis a23 e a24, com 360 linhas (no matlab eh colunas),
#que faz um circulo de 1 a -1
ar, ai, br, bi = np.loadtxt('lyg2.txt', unpack=True)
a23 = ar + 1j * ai
a24 = br + 1j * bi
#mesmo circulo agora com 460 linhas (no matlab eh colunas)
a26 = np.array( list(a23[310:360]) + list(a23) + list(a23[0:50]) )
a27 = np.array( list(a24[310:360]) + list(a24) + list(a24[0:50]) )
#cria vetor de 0 a 360 iniciando em 311 e terminando em 50
a30 = np.array( range(311,361) + range(1,361) + range(1,51) )
#??
grad1 = 0.0175 ; grad2 = 180/pi
#para o caso de usar matr1 (matriz de ocorrencias)
# sa=[.5,.5,.5,.5,0.1]
#o objetivo aqui eh ter wavelets prontas para usa-las de acordo com
#o pico das faixas; caso nao haja pico em uma faixa, usa-se wavelets
#correspondentes a: faixa 1 - 14.28 s (55 pontos), faixa 2 - 9.52 s
#(37 pontos), faixa 3 - 7.76 s (30 pontos ) e faixa 5- 3 s (12 pontos)
# ES - 12 graus
# mm=[60;55;50;46;43;40;38;35;33;32;30;29;27;26;25;24;23;22;21;21;20;19;...
# 19;18;18;17;17;16;16;15;15;15;14;14;14;13;13;13;12;12;12;12;12;11;...
# 11;11;11;11;10;10;10;10;10;10;9];
# ES - 32 graus
#cria vetor com o tamanho das wavelets
# mm=[64;50;48;44;38;32;30;27;25;24;21;19;18;17;16;15;14;13;12;11;11;10;10;9;9;8;8;8;7;7;...
# 7;7;6;6;6];
mm = range(64,5,-1)
ms=[];
#cria vetores de dim 64,34
wavecos = np.zeros((64,len(mm)))
wavesen = np.copy(wavecos)
for i in range(len(mm)):
mn = mm[i]
ms.append(mn)
#cria vetor de -pi a pi do tamanho de mn que eh o tamanho da wavelet
out2 = np.array([np.linspace(-3.14,3.14,mn)][:])
#cria janela de hanning para o tamanho da wavelet
gau = np.hanning(mn) ; gau = resize(gau,(1,len(gau)))
#cria wavelet cos
out1 = (gau * cos(3 * out2)).T
#cria wavelet sen
out3 = (gau * sin(3 * out2)).T
#coloca em cada coluna a wavelet de determinado
#tamanho. cria 34 wavelets?
wavecos[0:mn,i] = out1[:,0]
wavesen[0:mn,i] = out3[:,0]
#intervalo de amostragem
dt = 0.78
#tempo de amostragem, pq 64? devido ao g.l?
x = dt * 64
#carrega lista com o nome dos arquivos
#z3 = lista com o nomes
# lista = carrega_axys.lista_hne(pathname)
lista = listap
kkl = 0
#for ik in range(0,len(lista),3):
# for ik in range(p0,p1,3): #pula 3 arquivos para cada arq processado
for ik in range(len(listap)):
# print ik
#for ik in range(1):
#atribui o nome do arquivo a variavel 'arq'
#arq = lista[ik]
#atribui as variaveis em 'dados' e a data em 'data'
dados, data = loadhne.dados_hne(pathname,listap[ik])
eta = dados[0:1024,1]
dspy = dados[0:1024,2]
dspx = dados[0:1024,3]
co = eta
dd = dspx
dc = dspy
ano = int(data[0])
mes = int(data[1])
#limite superior (3db) e limite inferior (3 db)
# 1) 20 11.1
# 2) 11.1 8.69
# 3) 8.69 7.4
# 4) 7.4 4.0
# 5) 4.0 end
# a wavelet sera gerada com as regras acima
# serao calculadas as energias em cada faixa mencionada a partir do
# espectro de uma dimensao considerando que o espalhamento entre cada
# frequencia seja de 1/T
#calculo do espectro de uma dimensao
ww55 = zeros((10,1))
han = 1 #aplicacao da janela: han = 1 hanning ; han = 0 retangular
gl = 32
qq1 = espec.espec1(co,nfft,fs)
f1 = qq1[:,0]
qq1 = qq1[:,1] #auto-espectro
#faixas em segundos
#2 3 4
#4 6 7.2
#7.14 8 10.8
#10.3 16 20.0
#intervalo de frequencia
df = f1[1] - f1[0]
#onda significativa (coloca a altura na primeira linha de ww5)
ww55[0] = 4 * sqrt(sum(qq1) * df)
#espectros nas 4 faixas - 32 gl
ww55[1] = sum(qq1[1:5])
ww55[2] = sum(qq1[5:7])
ww55[3] = sum(qq1[7:14])
ww55[4] = sum(qq1[14:33])
#picos1 eh o valor da duracao da wavelet que sera usada
#correspondendo a 3 ciclos do periodo de interesse
#quando nao ha pico na faixa: 48=16s ; 27=9s ;
#18=6s ; 9=3s
picos1 = np.array([48,27,18,9])
#calcula a diferenca do vetor qq1 (ex: qq1[2] - qq1[1] = g1[1] )
g1 = np.diff(qq1)
#coloca 1 p/ valores >1, 0 p/ =0 e -1 <0
g1 = np.sign(g1)
#calcula a diferenca
g1 = np.diff(g1)
#acrescenta um valor no inicio de g1
g1 = np.array( [0] + list(g1) )
#acha indices dos picos
g1 = pl.find(g1 == -2)
#serao calculados os 4 maiores picos
#acha os valores dos picos (g4) e indices dos picos (g5)
g4 = sort(qq1[g1])
g5 = argsort(qq1[g1])
#g5 = range(len(g4)-1,-1,-1)
#fica igual ao g1 (matriz com picos em ordem crescente)
g6 = flipud(g1[g5])
#comeca criando a matriz com picos , pq??
#g6 = array( list(g6)+[0,0,0,0] )
#escolhe os 4 primeiros maiores?
#g6 = g6[0:4]
#retira valores maiores que 14 (pra tirar os picos em alta freq?)
g7 = g6[g6<14]
#cria faixas de frequencia (periodo) - pq nao usa faixa 4?
#no matlab esta transposto
faixa1 = np.array([3,4])
faixa2 = np.array([5,6])
faixa3 = np.array(range(7,14))
#colocacao dos picos nas primeiras faixas para determinacao das wavelets
picos2 = np.zeros((4,1))
for gh in range(len(g7)):
#se o valor de g7[gh] estiver dentro da faixa1
if g7[gh] in array(faixa1):
#acha o indice da faixa1 que esta o g7(gh)
#g8 = find(g7[gh] == faixa1)
picos2[0] = g7[gh]
faixa1 = 0
if g7[gh] in array(faixa2):
#acha o indice da faixa1 que esta o g7(gh)
#g8 = find(g7[gh] == faixa2)
picos2[1] = g7[gh]
faixa2 = 0
if g7[gh] in array(faixa3):
#g8 = find(g7[gh] == faixa3)
picos2[2] = g7[gh]
faixa3 = 0
# print gh
picos3 = picos1
# # o que faz isso? (esta dando erro no proc do mes de maio de 2009)
# for gh in range(4):
# if picos2[gh] > 0:
# picos1[gh] = round(3 * 1./f1[int(picos2[gh])-1])
#valores dos picos para o arquivo final
g5 = flipud(g5)
g5 = g1[g5]
g5 = list(g5) + [0,0,0,0]
g5 = array(g5[0:4])
g = find(g5 > array(0))
#correcao henrique
g5aux = []
for i in range(len(g)):
g5aux.append(64 / float(g5[i]))
if len(g5aux) < 4:
g5 = array(g5aux + [0,0,0,0])
g5 = g5[0:4]
#transforma em matriz de 4 col e 1 lin
g5 = resize(g5,(len(g5),1))
#preparo final do energ
ww55[6:11] = g5
energ[:,kkl] = ww55[:,0]
#serao calculadas 5 faixas com wavelets
#para cada wavelet calcula-se uma matriz de direcao
#e desvio padrao obtendo-se um D(teta) para cada faixa
for iwq in range(4):
#acha dentro de mm o indice do valor de picos[iwq]
g11 = find(picos1[iwq] == mm)
#acha o valor do periodo? da wavelet
m = mm[g11[0]]
#cria variavel out com a wavelet a ser utilizada (pega
#as linhas e colunas da wavelet)
out1 = wavecos[0:m,g11[0]]
out3 = wavesen[0:m,g11[0]]
#cria matriz com valores 1
matr1 = ones((20,90))
#perguntar p parente??
m1 = 1024 - m
#parametros para o calculo de tet2 e sp2
m3 = m1 ; m1 = m1 - 1 ; m3 = m1
m4 = 2 * dt / (m * 0.375) #para corrigir a janela de hanning
#como eu ja corrigi em espec1, preciso fazer?
m2 = m - 1
# ==============================================================================#
#daatRS21_32.m
#chama subrotina da daat
#CODE daatwaverider21w calculates the main direction
#for each segment with wavelet (morlet type);
#the formulatuio of Lygre and Krogstad is used
#usa-se a convolucao com a wavelet complexa
a1 = lfilter((out1 - 1j * out3), 1, co)
a2 = lfilter((out1 - 1j * out3), 1, dd)
a3 = lfilter((out1 - 1j * out3), 1, dc)
m4 = 2*dt / (m*0.375) #precisa fazer?
#pq pegar a partir de m?
a1 = a1[m-1:1025]
a2 = a2[m-1:1025]
a3 = a3[m-1:1025]
#espectros cruzados
z41 = a1
z42 = a2
z43 = a3
#espectros cruzados
a4 = m4 * (z41 * conj(z41))
a8 = m4 * imag(z41 * (- conj(z42)))
a9 = m4 * imag(z41 * (- conj(z43)))
a20 = m4 * (z42 * conj(z42))
a21 = m4 * (z43 * conj(z43))
a25 = a20 + a21
a7 = sqrt(a4 * a25)
a12 = m4 * real(z42 * conj(z43))
# #a8 eh o cosseno, projecao no eixo W-E
# #a9 eh o seno, projecao no wixo S-N
# #o angulo c0 calculado eh em relacao ao eixo horizontal
c0 = a8 + 1j * a9
c1 = c0 / a7
c01 = cos(c0)
c02 = sin(c0)
c03 = angle(mean(c01) + 1j * mean(c02))
c03 = ceil(c03 * 360 / (2 * pi))
c2 = (a20 - a21 + 1j * 2 * a12) / a25
c0 = angle(c0) * 360 / (2 * pi)
c0 = ceil(c0)
# c00 = find(c0<=0) ##pra que utiliza??
# c0[c00] = c0[c00] + 360 ## nenhuma variavel criada aqui esta sendo utilizada
# pq = ceil(mean(c0)) ##nao utiliza
# pq = c03
# g = find(pq <= 0)
# pq[g] = pq[g] + 360
p1 = (c1 - c2 * conj(c1)) / (1 - abs(c1) ** 2)
p2 = c2 - c1 * p1
tet2 = zeros((1,m3+2))
#in order to avoid the ambiguity caused by 2teta the main
#direction calculated by Fourier techniques is used
#as a reference; the mem value is calculated in an interval
#of 100 degrees around this value;
for kl in range(m3+2):
p3 = ceil(c0[kl])
d = list(arange(p3,p3+100))
z1 = 1 - p1[kl] * conj(a26[d]) - p2[kl] * conj(a27[d])
z1 = z1 * conj(z1)
#z1 = array([round(v,7) for v in real(z1)])
#minimum of denominator is sufficient to
#determine the maximum
p5 = find(z1 == min(z1))
p5 = p5[0]
p7 = a30[p3 + p5 - 1]
tet2[0,kl] = grad1 * p7
tet2 = tet2.T
sp2 = a4
# # ==============================================================================#
# #daatRS22_32.m
#CODE daatbcampos22.m to select the segments for
#the directional spectrum composition
################################################
#Prepared by C.E. Parente
################################################
it = 2 * (iwq - 1 + 1) + 1 #verificar, que teria que dar 1 e ta dando -1
q1 = cos(tet2).T
q2 = sin(tet2).T
#Preparing ensembles of m segments advancing one sample
#fr3 ia a matrix of cos and fr5 of sines of the segments whose direction
#stability will be investigated
#fr4 is the spectrum matrix
pm = len(arange(round(m/2.0),m1-(m-round(m/2.0))))+1
fr3 = zeros((round(m/2.0),pm))
fr5 = copy(fr3)
fr4 = copy(fr3)
for ip in arange(round(m/2.0)):
fr3[ip,:] = q1[0,ip:m1-(m-ip)+1]
fr5[ip,:] = q2[0,ip:m1-(m-ip)+1]
fr4[ip,:] = real(sp2[ip:m1-(m-ip)+1])
#using the mean and the standard circular deviation
#to select the segments with a given stability
fr2a = mean(fr3.T, axis=1)
fr2b = mean(fr5.T, axis=1)
r = sqrt(fr2a ** 2 + fr2b ** 2)
#circular deviation
fr9 = sqrt(2 * (1 - r))
#espectro medio por coluna
fr45 = mean(fr4.T, axis=1)
fr2 = angle(fr2a + 1j * fr2b)
#correcao para os valores ficarem entre 0 e 2pi
g = find(fr2 < 0) ; fr2[g] = fr2[g] + 2 * pi
g = find(fr2 > 2 * pi) ; fr2[g] = fr2[g] - 2 * pi
#g vai ser o comprimento do vetor
g = len(fr2)
a15 = 0
zm = 0.5
#segments with values of the standard deviations smaller
#than the threshold are selected
er5 = copy(fr45)
b7 = find(fr9 < zm)
a15 = fr2[b7]
er4 = mean(fr4[:,b7], axis=0)
#Correcting for declination
# a15 is the final vector with selected direction values
a15 = ceil(a15 * 360 / (2 * pi))
#a15 = 90 + a15 - 14 (waverider santa catarina)
#a15 = 90 + a15 - 21 (waverider de arraial)
#Boia ES dmag -23
#usando o EtaEW e EtaNS ja esta descontado a dmag
a15 = 270 - a15
g = find(a15<0) ; a15[g] = a15[g] + 360
g = find(a15>360) ; a15[g] = a15[g] - 350
#caixas para acumulo e obtencao de D(teta)
w1 = zeros((360,1)) #direcao principal
w2 = zeros((360,1)) #ocorrencias
a16 = copy(a15)
if len(a15) > 1: #caso existam valores selecionados
b1 = find(a15<=0) ; a15[b1] = a15[b1] + 360
b1 = find(a15>360) ; a15[b1] = a15[b1] - 360
#a15 = round(a15)
for k in range(len(a15)):
bb = a15[k]
w1[bb-1] = w1[bb-1] + real(sp2[k])
w2[bb-1] = w2[bb-1] + 1
[b,t1] = butter(6,0.075)
#b = resize(b,(len(b),1))
#t1 = resize(t1,(len(t1),1))
#filtrando w1 para determinar o D(teta)
xx = array(list(w1[321:361]) + list(w1) + list(w1[0:41]))
xx = xx[:,0]
x = filtfilt(b,t1,xx)
x = x[41:401]
g = find(x<0)
x[g] = 0
#calculando as duas direcoes
g1 = diff(x)
g1 = sign(g1)
g1 = diff(g1)
g1 = array([0] + list(g1) )
g1 = find(g1 == -2)
p1 = sort(x[g1])
p2 = argsort(x[g1])
if len(p1) > 0:
p = array(list(flipud(g1[p2])) + [0])
p = p[0:2]
e = array(list(flipud(p1)) + [0])
e = e[0:2]
#joga fora valores espacados menos de 50 graus
if abs(p[0] - p[1]) < 20:
p[1] = 0
p[1] = 0
elif e[1] < 0.1 * e[0]:
e[1] = 0
p[1] = 0
z1 = ww55[iwq + 1]
p = array(list(p) + [0,0,0])
p = p[0:2]
e = array(list(p) + [0,0,0])
e = e[0:2]
e = e * z1 / sum(e)
dire1[it-1:it+1,kkl] = p
espe1[it-1:it+1,kkl] = e
kkl = kkl + 1
toc = time.clock()
texec = toc - tic
print 'Tempo de execucao DAAT (s): ', texec
return espe1, energ, dire1
dados = np.loadtxt(os.environ['HOME'] + '/Dropbox/lioc/dados/pnboia/triaxys/rio_grande/HNE/200912130600.HNE', skiprows = 11) t = dados[:,0] - dados[0,0] eta = dados[:,1] # ------------------------------------------------- # #calcula parametros de onda para a serie normal #param = [Hs,H10,Hmax,Tmed,THmax] #parametros de onda no tempo etat = proconda.ondat(t,eta,200) #parametros de onda na frequencia etaf = espec.espec1(eta,328,1.28) hm0 = 4.01 * sp.sqrt(sum(etaf[:,1]) * (etaf[0,0])) # ------------------------------------------------- # #cria serie perturbada etap = cp.copy(eta) #etap1 = cp.copy(eta) #numero de perturbacoes npt = 50 #duracao da perturbacao dpt = 50 #posicoes aleatorias das perturbacoes
#coloca data em datetime df.index = pd.to_datetime(df.date, format='%d/%m/%Y %H:%M') dfp.index = df.index #mare mateorologica dfp.mm = df.mare - dfp.prev mmm = df.mare - dfp.prev #dfp.index = pd.to_datetime(dfp.date, format='%d/%m/%Y %H:%M') fs = 1.0 / (5.0 / 60 / 24) nfft = len(df) / 2 #calculo do espectro aa = espec.espec1(df.mare, nfft, fs) #espectro mare meteo aamm = espec.espec1(dfp.mm, nfft, fs) aap = espec.espec1(dfp.prev, nfft, fs) #achar a onda de mare meteo dfp.Mareonda = pd.rolling_mean(dfp.mm, 1080) onda = dfp.Mareonda - np.mean(dfp.Mareonda) pl.figure() pl.plot(df.index, df.mare) pl.figure() pl.semilogx(aa[:, 0], aa[:, 1], 'b') pl.semilogx(aamm[:, 0], aamm[:, 1], 'r')
