"""
from __future__ import division
from os import sys
sys.path.append('../pyseries/')
import lectura as lec
import signals as sig
import numpy as np
import matplotlib.pyplot as plt
y, U, V = lec.plot_txt_waves('Dcolina', 0.0005)
N = len(U)
T_t = N * 0.0005
#
FS = 10.0
x1, Samag1, A1, nfs1 = sig.Ftrans(U, N, T_t / N, FS)
lec.grafFourier(Samag1, x1, nfs1, 'result', 0.0, 16.0, 0.0, 1000.0, 2)
#N = 3999
#T_t = 2.0
#tc = 1.0
#fc = 4.0
#t_b = np.sqrt(6)/np.pi/fc
#print ("Breadth =") , t_b , ('s')
#Rick , time = sig.ricker(N , T_t , tc, fc)
#lec.grafsignalG(Rick , 'Pulse', 'Disp','L' ,-1.0,+1.0, T_t/N , 3)
#
#x2 , Samag2 , A2 , nfs2 = sig.Ftrans(Rick , len(Rick) , T_t/N , FS)
#lec.grafFourier(Samag2 , x2 , nfs2 , 'result' , 0.0 , 16.0 , 0.0 , 750.0 , 4)
#
#plt.figure(5)
# -*- coding: utf-8 -*-
"""
Created on Wed Nov 11 12:36:56 2015
@author: eafit
"""
import numpy as np
from os import sys
sys.path.append('../CALCULATOR/')
import signals as sig
import matplotlib.pyplot as plt
from sympy import init_printing
init_printing()
"""
Creates model.
"""
fc = 4.0
Tt = 2.0/fc
tc = Tt/2
dt = 0.0005
nt = int(Tt / dt )
Rick, time = sig.ricker(nt , Tt , tc, fc)
plt.plot(time , Rick)
x , Samag , A , nfs = sig.Ftrans(Rick , nt , dt , Tt)
sig.grafFourier(Samag , x , nfs , 'FAS', 0.0 , 4.0 , 0.0 , 0.2 , 2)
#np.savetxt('respuesta.txt' , SOL )
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Script for post-processing acceleration time histories
resulting from the ray visualizer in the elastic calculator
"""
from __future__ import division, print_function
import matplotlib.pyplot as plt
import numpy as np
import signals as sig
#
# Process input motion
#
plt.figure(0)
dt = 0.077
fs = 10.0
DATOS = np.loadtxt('respuesta.txt')
ninc = 129
signal = np.zeros([ninc, 21], dtype=float)
k = 0
for j in range(5, 26):
for i in range(ninc):
signal[i, k] = DATOS[j, i] + k / 5
sig.grafsignalG(signal[:, k], 'salida', 'Displacement', 'l', 0.0, 20.0, dt,
0)
x, Samag, A, nfs = sig.Ftrans(signal[:, k], 129, dt, fs)
sig.grafFourier(Samag, x, nfs, 'Fourier', 0.0, 0.0, 0.0, 0.0, 1)
k = k + 1
sig.grafsignalG(signal[:, 5], 'salida', 'Displacement', 'l', 0.0, 20.0, dt, 2)
def single_ray(x, y, Gamma, Beta, Tt, Tc, fc):
"""Evaluates a plane wave
Parameters
----------
x : float
x-coordinate
y : float
y-coordinate
Gamma: float
Angle of incidence
Beta: float
Velocity of wave propagation
Returns
-------
signal : ndarray (float)
Array with the time history at the point x-y.
"""
#
# Pulse parameters
#
dt = 1.0 / (8.0 * fc)
Nt = int(Tt / dt)
Nf = int((Nt - 1) / 2)
df = 1 / (Nt * dt)
lif = df
lff = df * Nf
fre = np.linspace(lif, lff, Nf, dtype=float)
desplaz = np.zeros(len(fre), dtype=complex)
#
nx1 = np.sin(Gamma)
ny1 = -np.cos(Gamma)
#
# nx2 = np.sin(2.9*Gamma)
# ny2 =-np.cos(2.9*Gamma/3.0)
#
# Compute the Transfer function
#
for j in range(0, len(fre)):
kapa = 2.0 * np.pi * fre[j] / Beta
pha_ang_1 = -kapa * (nx1 * x + ny1 * y)
# pha_ang_2 = - kapa*(nx2*x + ny2*y)
# desplaz[j] = np.exp(1j*pha_ang_1) + np.exp(1j*pha_ang_2)
desplaz[j] = np.exp(1j * pha_ang_1)
#
# Compute convolution and inverse transform.
#
TF = np.zeros(Nt, dtype=complex)
Rick, T = sig.ricker(Nt, Tt, Tc, fc)
x, Sas, Saf, nfs = sig.Ftrans(Rick, Nt, dt, 10.0)
for i in range(Nf):
TF[i + 1] = desplaz[i]
TF[-1 - i] = np.conj(desplaz[i])
for i in range(Nt):
TF[i] = Saf[i] * TF[i]
signal = sig.IFtrans(TF, Nt, dt)
return signal
def DifractionSesma(x, y):
Ui = 1j
v = 3 / 2
r0 = 10
phi0 = 20 * np.pi / 180
r = np.sqrt((x)**2 + (y)**2)
phi = np.arctan(x / y)
R = [r, r0]
Beta = 1.0 # Velocidad de la onda incidente en el medio
Tt = 16.0 #Tiempo total que tendrá el pulso
Tc = 4.0 # Tiempo en el que estará centrado el pulso
fc = 1.0 # Frecuencia del pulso
Nf = 2048
Nt = 2 * Nf + 1
dt = Tt / (Nt - 1)
deta = 2.0 / Beta / Tt # Delta de frecuencias
neta = int(4 * fc * 2 / deta) # Número de frecuencias que se evaluaran
lieta = deta # #Límite inferior para eta
lfeta = deta * neta # Límite superior para x
Eta = np.linspace(lieta, lfeta, neta, dtype=float)
W = np.zeros(len(Eta), dtype=complex)
Vdt = np.zeros(Nt)
for i in range(Nt):
Vdt[i] = i * dt
def Especiales(
Delta,
f): # El parámetro f define cuál de los vectores voy a retornar
sumatoria = 100 #Número de veces que se van a evaluar las sumatorias de Hankel
H = np.zeros((sumatoria), dtype=complex) # Vector Hankel
B = np.zeros((sumatoria)) # Vector Bessel
if f == 0:
for i in range(0, sumatoria):
H[i] = sci.hankel1(i, Delta)
return (H)
else:
for i in range(0, sumatoria):
B[i] = sci.jv(i, Delta)
return (B)
for j in range(0, len(Eta)):
k = Eta[j] / Beta
r = min(R)
bessel = Especiales(k * r, 1)
r = max(R)
hankel = Especiales(k * r, 0)
S = hankel * bessel
wii = 0
n = 100
for i in range(n):
En = 0
if i == 0:
En = 1
else:
En = 2
wi = (Ui / (2 * v)) * En * np.cos(
(i / v) * (phi + v * np.pi * 0.5)) * np.cos(
(i / v) * (phi0 + v * np.pi * 0.5)) * S[i / v]
wii = wii + wi
W[j] = wii
Rick, T = sig.ricker(Nt, Tt, Tc, fc)
x, Sas, Saf, nfs = sig.Ftrans(Rick, Nt, dt, 10.0)
TF = np.zeros(Nt, dtype=complex)
for i in range(neta):
TF[i + 1] = W[i]
TF[-1 - i] = np.conj(W[i])
for i in range(Nt):
TF[i] = Saf[i] * TF[i]
signal = sig.IFtrans(TF, Nt, dt)
return (signal)
def trifunac(x, y, Gamma, a):
"""
Author: Juan Fernando Zapata
Writes VTK files for visualization with paraview
"""
##################### DEFINICIÓN DE LOS VECTORES CON LOS TÉRMINOS DE HANKEL Y BESSEL ######################
def Especiales(
Delta,
f): # El parámetro f define cuál de los 4 vectores voy a retornar
sumatoria = 130 #Número de veces que se van a evaluar las sumatorias de Hankekl
H = np.zeros((sumatoria), dtype=complex) # Vector Hankel
B = np.zeros((sumatoria)) # Vector Bessel
if f == 0:
for i in range(0, sumatoria):
H[i] = sci.hankel2(i, Delta)
return (H)
else:
for i in range(0, sumatoria):
B[i] = sci.jv(i, Delta)
return (B)
#############################################################################################################
Beta = 1.0 # Velocidad de la onda incidente en el medio
# Gamma = 0.523 # Ángulo de incidencia de la onda
# a = 1.0 # Radio del cañón
Tt = 16.0 #Tiempo total que tendrá el pulso
Tc = 4.0 # Tiempo en el que estará centrado el pulso
fc = 1.0 # Frecuencia del pulso
Nf = 2048
Nt = 2 * Nf + 1
dt = Tt / (Nt - 1)
deta = 2.0 * a / Beta / Tt # Delta de frecuencias
neta = int(4 * fc * 2 / deta) # Número de frecuencias que se evaluaran
lieta = deta # #Límite inferior para eta
lfeta = deta * neta # Límite superior para x
Eta = np.linspace(lieta, lfeta, neta, dtype=float)
desplaz = np.zeros(len(Eta), dtype=complex)
suma = 64
if (y == 0):
r = abs(x)
if (x < 0):
tetha = -np.pi / 2.0
else:
tetha = np.pi / 2.0
elif (x == 0):
r = y
tetha = 0.0
else:
r = np.sqrt((x)**2 + (y)**2)
tetha = np.arctan(x / y)
for j in range(0, len(Eta)): # Variación de frecuencias para cada X
kappa = (np.pi / a) * Eta[j]
ka = kappa * a
kr = kappa * r
Hankel = Especiales(kr, 0) #Vector de Hankel con argumento kr
Bessel = Especiales(kr, 1) # Vector de Bessel con argumento kr
######################################### CÁLCULO DEL INCOMING ###########################################
S1 = 0 # Acumulador de la primera sumatoria del incoming
S2 = 0 #Acumulador de la segunda sumatoria del incoming
for i in range(0, suma): #Términos de la sumatoria
n1 = i + 1
S1 = S1 + ((-1)**n1 * Bessel[2 * n1] * np.cos(2 * n1 * Gamma) *
np.cos(2 * n1 * tetha))
S2 = S2 + ((-1)**i * Bessel[2 * i + 1] * np.sin(
(2 * i + 1) * Gamma) * np.sin((2 * i + 1) * tetha))
incoming = (2.0 * Bessel[0]) + (4.0 * S1) - (4j * S2)
############################################## CÁLCULO DEL SCATTER #############################################
Hanka = Especiales(ka, 0) # Vector de hankel con argumento ka
Beka = Especiales(ka, 1) # Vector de Bessel con argumento ka
A0 = -2.0 * (Beka[1] / Hanka[1])
B0 = 4j * np.sin(Gamma) * ((ka * Beka[0] - Beka[1]) /
(ka * Hanka[0] - Hanka[1]))
scatter = 0
for i in range(0, suma):
if i == 0:
scatter = scatter + (A0 * Hankel[2 * i] * np.cos(2 * i * tetha)
+ B0 * Hankel[2 * i + 1] * np.sin(
(2 * i + 1) * tetha))
else:
An = -4 * (-1)**i * np.cos(2 * i * Gamma) * (
(ka * Beka[2 * i - 1] - 2 * i * Beka[2 * i]) /
(ka * Hanka[2 * i - 1] - (2 * i) * Hanka[2 * i]))
Bn = 4j * ((-1)**i) * np.sin(
(2 * i + 1) * Gamma) * ((ka * Beka[2 * i] -
(2 * i + 1) * Beka[2 * i + 1]) /
(ka * Hanka[2 * i] -
(2 * i + 1) * Hanka[2 * i + 1]))
scatter = scatter + (An * Hankel[2 * i] * np.cos(2 * i * tetha)
+ Bn * Hankel[2 * i + 1] * np.sin(
(2 * i + 1) * tetha))
desplaz[j] = incoming + scatter
#return(desplaz) #Tener en cuenta el lugar del return
Rick, T = sig.ricker(Nt, Tt, Tc, fc)
x, Sas, Saf, nfs = sig.Ftrans(Rick, Nt, dt, 10.0)
TF = np.zeros(Nt, dtype=complex)
for i in range(neta):
TF[i + 1] = desplaz[i]
TF[-1 - i] = np.conj(desplaz[i])
for i in range(Nt):
TF[i] = Saf[i] * TF[i]
signal = sig.IFtrans(TF, Nt, dt)
return (signal)