def multitaper(self, opcion_senal, inicio, fin, bw, t, p, multiply, fs, state_DC):
'''
Función que tiene como objetivo realizar el análisis del método multitaper,
recibe la banda de paso que se va a analizar y los parámetros W (frec. cercanas)
T (tiempo de duración de la ventana) ,P(cantidad de ventanas ortogonales) y el
factor que da indicios de la cantidad de segmentos que se tomarán, que son
necesarios para este modelo y devuelve finalmente los parámetros de frecuencia
y valores que darán el gráfico del resultado.
'''
if state_DC==False:
params = dict(fs = fs, fpass = [inicio, fin], tapers = [bw, t, p], trialave = 1)
# Se mantiene la relación para garantizar los valores correctos para el reshape
x = int(self.__data[opcion_senal].shape[0]/(fs*multiply))
datos = self.__data[opcion_senal]
datos = datos[:fs*multiply*x]
data = np.reshape(datos, (fs*multiply, x),order='F')
Pxx,f = mtspectrumc(data, params)
else:
datos = self.__data[opcion_senal]
datos = datos - np.mean(datos)
params = dict(fs = fs, fpass = [inicio, fin], tapers = [bw, t, p], trialave = 1)
x = int(datos.shape[0]/(fs*multiply))
datos = datos[:fs*multiply*x]
data = np.reshape(datos, (fs*multiply, x),order='F')
Pxx,f = mtspectrumc(data, params)
return Pxx,f
def multitaper_analisis(
self, datos, fs, w, t, n_t, fmin, fmax, first_parametro
): #algoritmo que realiza los calculos para obtener el analisis por multitaper
#quita el nivel DC restándole la media
datosv = np.array(datos) - np.mean(np.array(datos))
#evito errores lógicos
if fmin >= fmax:
return None
p = (2 * w * t) - n_t #obtencion del parámetro p de los tapers
params = dict(fs=fs, fpass=[fmin, fmax], tapers=[w, t, p], trialave=1)
#para que de en cualquier cantidad de datos que se elijan de la senal
segmentos = (len(datosv) / (fs * first_parametro))
if type(segmentos) == float:
segmentos1 = round(
segmentos
) #si se obtien un decimal, aproxima al valor mas cercano
x = first_parametro * fs * segmentos1
datos_new = datosv[:x] #nuevo vector de datos
data1 = np.reshape(
datos_new, (first_parametro * fs, segmentos1), order='F'
) #reshape no recibe datos flotantes por lo que se aproxima al dato mas cercano y se define un nuevo vector de datos
Pxx1, f1 = mtspectrumc(data1, params)
return (f1, Pxx1) #devuelvo la frecuencia y la potencia
data = np.reshape(
datosv, (first_parametro * fs, segmentos), order='F'
) #generacion de la nueva matriza partir de los parametros y los datos del canal seleccionado
Pxx, f = mtspectrumc(data, params)
return (f, Pxx)
def calcularPSD_Multitaper(self,segmentos,fs,fcMin,fcMax,W,T,p,trialAverage):
if self.senalFiltrada.shape[0] == 0: # Sí ya hay una señal filtrada
if self.banderaDimension == 1: # se trabajará con ella, de lo contrario
senal = self.senal; # se empleara la señal original
elif self.banderaDimension == 2:
if self.canalActual == -1:
senal = self.senal[0];
else:
senal = self.senal[self.canalActual];
else:
senal = self.senalFiltrada;
senal = senal - np.mean(senal); # MECANISMO
N = senal.shape[0]; # De igual forma al anterior, se establecen
numero = N/(segmentos*fs); # los límiter de los parámetros, y se calculan
# las muestras que debe tener cada segmento de
K = 2*T*W-p; # la señal; segmentos que serán multiplicado por
# K < M, quien es M? # los Slepian del algoritmo Multitaper
if (int(fs*numero)*segmentos == N) & (K > 0 & K < N) & (trialAverage < segmentos):
senalSegmentada = np.reshape(senal,(int(fs*numero),segmentos),order = 'F');
parametros = dict(fs = fs, fpass = [fcMin, fcMax], tapers = [W, T, p], trialave = trialAverage);
PSD, f = mtspectrumc(senalSegmentada,parametros);
self.__controlador.graficarPSD(f,PSD);
def analizar_multitaper(self, senal1, fs, fpassi, fpassf, W, T,
p): #analisis usando multitaper scipy 1.1.0
from chronux.mtspectrumc import mtspectrumc
params = dict(fs=fs,
fpass=[fpassi, fpassf],
tapers=[W, T, p],
trialave=1)
data = np.reshape(senal1, (fs * 5, 10), order='F')
#Calculate the spectral power of the data
self.Pxx, self.f = mtspectrumc(data, params)
return (self.Pxx, self.f)
def devolver_canal_filtradomulti(self, senal1, fs, fpassmenor, fpassmayor,
factor, ventana, P):
from chronux.mtspectrumc import mtspectrumc
senal1 = np.squeeze(senal1[0, :])
#tomo solamente los datos que voy a trabajar de mi señal
senal1 = senal1 - np.mean(senal1)
#le quito el valor dc a la señal mediante el valor promedio
params = dict(fs=fs,
fpass=[fpassmenor, fpassmayor],
tapers=[factor, ventana, P],
trialave=1)
data = np.reshape(senal1, (fs, 10 * 5), order='F')
Pxx, f = mtspectrumc(data, params)
return f, Pxx
def analice(
self, w, t, p, smin, smax, num
): #realiza el analisis de por multitaper, y devuelve las frecuencias y la potencia como vector
size = int(len(self.senial) / (self.fs * int(num)))
params = dict(
fs=self.fs,
fpass=[int(smin), int(smax)],
tapers=[int(w), int(t), int(p)],
trialave=1
) #se ingresan los parametros con los que se realiza el analisis multitaper
data = np.reshape(self.senial, (self.fs * size, int(num)), order='F')
pxx, f = mtspectrumc(data, params) #genera el analisis de multitaper
return pxx, f
def multitaper(self, frec1, frec2, W, T, P, num_seg):
params = dict(fs=self.__fs,
fspass=[frec1, frec2],
tapers=[W, T, P],
trialave=1)
x = int(self.__datos.shape[0] / (self.__fs * num_seg))
print(x)
datos = self.__data[self.__key]
datos = datos - np.mean(datos)
#print(datos)
datos = datos[:self.__fs * num_seg]
#print(datos)
data = np.reshape(datos, (self.__fs * num_seg, x), order='F')
Pxx, f = mtspectrumc(data, params)
return f, Pxx
def calcularMultitaper(self,data,fmp,ab,tam,inicial,final): #funcion para ejecutar el codigo del multitaper
data =self.__data[:]
sen= data - np.mean(data)
from chronux.mtspectrumc import mtspectrumc # se importa la liberia necesaria para su ejecucion
params = dict(fmp = fmp, fpass = [inicial, final], tapers = [ab, tam, 1], trialave = 1) # en esta variable queda los datos del multitaper
data = np.reshape(sen,(fmp*5,10),order='F') #esta variable reliza un redimension de los datos
#Calculate the spectral power of the data
Pxx, f = mtspectrumc(data, params) # se gurada en esta variables los datos resultado del mtspectrum
#A numeric vector [W T p] where W is the
#bandwidth, T is the duration of the data and p
#is an integer such that 2TW-p tapers are used.
return Pxx, f # se envian para ser graficados o utilizados donde se llamen
def Me_Multi(self):
self.senal = self.senal - np.mean(self.senal)
fsm = int(self.fsm.text())
flow = int(self.flow.text())
fhigh = int(self.fhigh.text())
w = int(self.multiw.text())
t = int(self.multit.text())
p = int(self.multip.text())
params = dict(fs=fsm,
fpass=[flow, fhigh],
tapers=[w, t, p],
trialave=1)
data = np.reshape(self.senal, (fsm * 5, 10), order='F')
Pxx, f = mtspectrumc(data, params)
Pxx = Pxx[(f >= 4) & (f <= 40)]
Pxx = Pxx.reshape(1, len(Pxx))
self.__coordinador.recibirDatosSenal(Pxx)
self.__x_min = 0
self.__x_max = 2000
self.__sc.graficar_datos(
self.__coordinador.devolverDatosSenal(self.__x_min, self.__x_max))
def analisis_f(self, fmin, fmax):
"""
Esta funcion efectua los metodos de Welch, Multitaper y Wavelet continuo para el analisis frecuencial
Parameters
----------
fmin : Limite inferior de intervalo de la frecuencia de interes .
fmax : Limite superior de intervalo de la frecuencia de interes.
"""
key = self.lineEdit.text()
data = self.data[key]
self.__coordinador.recibirDatosSenal(data)
#se devuelven los datos de la senal seleccionada
x = self.__coordinador.devolverDatosSenal(self.__x_min,
self.__x_max)[0]
#se elimina el nivel DC de la senal, si el usuario lo indica
#se hace restandole a los datos la media de los mismos
if self.nivel_DC.isChecked() == True:
x = x - np.mean(x)
tipo = self.metodo.currentIndex()
fs = int(self.campo_frecuencia.text())
#dependiendo del metodo seleccionado por el usuario se efectuan diferentes procesos
if tipo == 0: #metodo Welch
if self.campo_tamano.text() == "" or self.campo_solapamiento.text(
) == "":
#se valida que los parametros necesarios para realizar los calculos no esten en blanco
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Information)
msg.setText("Informacion")
msg.setWindowTitle('Advertencia')
msg.setInformativeText('Faltan campos por llenar')
msg.show()
else:
tamano = int(
self.campo_tamano.text()) #Ancho de la ventana en muestras
solapamiento = int(
self.campo_solapamiento.text()) #solapamiento en muestras
f, Pxx = signal.welch(x,
fs,
'hamming',
tamano,
solapamiento,
scaling='density')
title = "Análisis por método de Welch"
self.__sc1.graficar_frecuencia(f, Pxx, fmin, fmax, title)
elif tipo == 1: #metodo multitaper
self.graficar_key()
self.__coordinador.recibirDatosSenal(data)
x = self.__coordinador.devolverDatosSenal(self.__x_min,
self.__x_max)[0]
if self.nivel_DC.isChecked() == True:
x = x - np.mean(x)
if self.campo_duracion.text() == "" or self.campo_ancho.text(
) == "" or self.campo_p.text() == "" or self.segmentos.text(
) == "":
#se valida que los parametros necesarios para realizar los calculos no esten en blanco
msg = QMessageBox(self)
msg.setIcon(QMessageBox.Information)
msg.setText("Informacion")
msg.setWindowTitle('Advertencia')
msg.setInformativeText('Faltan campos por llenar')
msg.show()
else:
#se inicializan los parametros
W = int(self.campo_duracion.text())
T = int(self.campo_ancho.text())
p = int(self.campo_p.text())
N = int(self.segmentos.text())
#se crea un vector con ellos
params = dict(fs=fs,
fpass=[fmin, fmax],
tapers=[W, T, p],
trialave=1)
#se hace un reshape de los datos
primer_termino = x.shape[0] / N
#se hace un ceil para no tomar el valor flotante
primer_termino = int(np.ceil(primer_termino))
#se encuentra el tamano final
shape_final = primer_termino * N
#se agregan ceros para que los tamanos coincidan
nuevo_x = np.zeros([shape_final])
nuevo_x[0:x.shape[0]] = x
data = np.reshape(nuevo_x, (primer_termino, N), order='F')
#Se calcula el espectro de los datos
Pxx, f = mtspectrumc(data, params)
title = "Análisis por método Multitaper"
self.__sc1.graficar_frecuencia(f, Pxx, fmin, fmax, title)
else: #metodo Wavelet contiuo
tiempo, freq, power = self.__coordinador.calcularWavelet(
x, fmin, fmax, fs)
self.__sc1.graficar_espectro(tiempo, freq, power, fmin, fmax)
#Se habilitan campos y botones
self.campo_tamano.setEnabled(False)
self.campo_solapamiento.setEnabled(False)
self.adelante_esp.setEnabled(True)
self.atras_esp.setEnabled(True)
plt.subplot(2, 1, 2) plt.plot(f[(f >= 4) & (f <= 40)], Pxx[(f >= 4) & (f <= 40)]) plt.show() #%%analisis usando multitaper from chronux.mtspectrumc import mtspectrumc #A numeric vector [W T p] where W is the #bandwidth, T is the duration of the data and p #is an integer such that 2TW-p tapers are used. params = dict(fs=fs, fpass=[0, 50], tapers=[4, 2, 1], trialave=1) data = np.reshape(anestesia, (fs * 5, 10), order='F') #Calculate the spectral power of the data Pxx, f = mtspectrumc(data, params) plt.plot(f[(f >= 4) & (f <= 40)], Pxx[(f >= 4) & (f <= 40)]) plt.show() #%%analisis usando multitaper from chronux.mtspectrumc import mtspectrumc #A numeric vector [W T p] where W is the #bandwidth, T is the duration of the data and p #is an integer such that 2TW-p tapers are used. params = dict(fs=fs, fpass=[0, 50], tapers=[4, 2, 1], trialave=1) data = np.reshape(anestesia, (fs * 5, 10), order='F') #Calculate the spectral power of the data