# -*- coding: utf-8 -*-
"""
Created on Wed Jul 22 18:49:57 2020

@author: User
"""

#%%
#cargamos las librerias de python que necesistmos:
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
import os
from IPython import get_ipython

#%% ------------------------ Elegir modo de salida de los gráficos -----------------------------------
'''
Descomentar la línea que corresponda. 
Si quieren que las figuras aparezcan en la terminal: inline 
Si quieren que las figuras aparezcan en una ventana emergente: qt5
'''
#get_ipython().run_line_magic('matplotlib', 'inline')
get_ipython().run_line_magic('matplotlib', 'qt5')


#%% ---------------------- Carga de datos ---------------------------------------


# Colocar la ruta de la carpeta con los archivos entre r' ':
os.chdir (r'G:\Mi unidad\Labo 3 1er cuat 2022\Clase 04 19\Mediciones')

# Nombre del archivo a analizar entre ' ' con la terminación .txt incluida:
file = '1100.txt'
resist=float(os.path.splitext(file)[0])
print(resist) 
# Valor de la resistencia que están usando en Ohms


'''
Con np.loadtxt(ruta) podemos cargar los datos de una matriz guardada en un
archivo de texto como un array de numpy. Cada renglón es una fila.
Las columnas están separadas por una coma. Eso lo indicamos en el "delimiter".
Con skiprows=1 le pedimos que se saltee la primer fila, que tiene los títulos.
'''

data = np.loadtxt(file,dtype=float,delimiter = ' ',skiprows= 1)

'''
Armamos arrays(vectores) con las columnas de mi archivo:
'''

x1i = data[:,0] #columna de tiempo en segundos
y0i= data[:,1] #tensión de entrada
y1i = data[:,2] #caida de tensión sobre la bobina
y2i= (data[:,1]-data[:,2])/resist   #corriente del circuito [ I = (V1-V2)/R ]



#%% ----------------------------- Gráfico de los datos crudos-----------------------

'''
Graficamos los datos tal cual salieron del Arduino, ordenados según el voltaje,
para observar si su comportamiento es lineal o no en una primera instancia.
'''

plt.ion() # Activa el modo interactivo del gráfico.

plt.close('all') # Cierro los gráficos abiertos por si había alguno.


'''
La función plt.subplots() me crea una figura 'fig' y ejes 'ax1, que en principio están vacíos.
Los vamos a llenar con la función plot.
Graficamos el vector numdatos que creamos contra los valores de tensión en el eje ax1 con color verde
ax2.ax1.twinx() crea un segundo eje en el mismo gráfico, compartiendo el mismo eje X con ax1.
En este segundo eje graficamos la corriente en rojo.
Las funciones 
'''
#Graficando nuestros datos en función del número de dato

fig, ax1 = plt.subplots()
ax1.plot(x1i, y1i,'.-g');
ax1.set_ylabel('Tensión(Vc)');
ax1.set_xlabel('Tiempo');
ax2=ax1.twinx()
ax2.plot(x1i, y2i,'.-r')
ax2.set_ylabel('Corriente(A)', color='r')

#%% ----------------------------- Seleccionar los ciclos a analizar-----------------------

"""
Vamos a limitar los datos al rango de interés
Con el ciclo elegido armamos 2 variables que nos den el primer y último dato de cada ciclo.
Para eso consideramo que Arduino nos da 80 datos por cada ciclo.
"""

#limitar los datos al rango de interés
j=5
datoinicial1=0
datofinal1=0
dif=0
n=5
tolerancia=1.0
while dif<tolerancia:   
    j=j+1
    dif=y0i[j]-y0i[j-n]
else:
    datoinicial1=j-n #dato inicial del ciclo ON

dif=y0i[j-n]-y0i[j]    

while dif<tolerancia:   
    j=j+1
    dif=y0i[j-n]-y0i[j]
else:
    datofinal1=j-2*n #dato final del ciclo ON

datoinicial2=j #inicio ciclo OFF
datofinal2=datoinicial2+datofinal1-datoinicial1 #fin ciclo OFF
"""
Con esos valores nos armamos nuevos vectores para graficar y analizar
Si tengo un vector X, y quiero elegir un recorte dentro de este, por ejemplo desde el dato 10 hasta el 20,
puedo usar X[10,20].
En las siguientes definiciones usamos esto para armar los vectores nuevos.
"""
#Ciclo ON
x1=x1i[datoinicial1:datofinal1]-x1i[datoinicial1] #para llevar el tiempo inicial a 0s 
y1=y1i[datoinicial1:datofinal1]
y2=y2i[datoinicial1:datofinal1]
y0=y0i[datoinicial1:datofinal1]
#x1corr=x1i[datoinicial1+5:datofinal1]
#y2corr=y2i[datoinicial1+5:datofinal1]

"""
Graficamos de igual manera que antes estos nuevos datos restringidos al ciclo elegido
"""
fig, y1x = plt.subplots()
y1x.plot(x1, y1,'.-g');
y1x.set_ylabel('Caída de tensión en L (V)');
y1x.set_xlabel('tiempo(s)');
y2x=y1x.twinx()
y2x.plot(x1, y2,'.-r')
y2x.set_ylabel('Corriente(A)', color='r')




#%%
"""
Definimos las funciones que vamos a usar para el ajuste de la carga del capacitor: 
exponenciales decrecientes (con un offset para la tensión)  
"""
Ifinal= y2[-10] # me da el valor final que alcanza la corriente del circuito
def corriente(time, a,b):
    y= a*np.exp(-time*b)+Ifinal
    return y


 
def tension(time, c,d):
    z= c*np.exp(-time*d)
    return z


"""
Defino los parámetros que voy a usar
"""

# Ajuste de los datos de corriente
popt2, pcov2 = curve_fit(corriente, x1,y2)
# Ajuste de los datos de tensión
popt1, pcov1 = curve_fit(tension, x1,y1)


"""
Armo funciones con los parámetros que obtuve del ajuste
"""
i=corriente(x1,*popt2)
vL=tension(x1,*popt1)
# ESTIMO LOS ERRORES ( 1 sigma )
perr1 = np.sqrt(np.diag(pcov1))

perr2 = np.sqrt(np.diag(pcov2))



#Grafico los resultados expermientales con el ajuste de la tensión de la bobina. 
plt.figure(3)
plt.scatter(x1, y1,  label='data')
plt.plot(x1, vL, color = 'red', linewidth = 2.0, label='fit')
plt.xlim(x1[0],x1[len(y1)-1])
plt.xlabel("Tiempo (s)")
plt.ylabel("Tensión (V)")
plt.title("RL transitorio")
plt.legend()

#Grafico los resultados experimentales con el ajuste de la corriente
plt.figure(4)
plt.scatter(x1, y2,  label='data')
plt.plot(x1, i, color = 'red', linewidth = 2.0, label='fit')
plt.xlim(x1[0],x1[len(y1)-1])
corrmin=min(y2[0],y2[len(y2) -1]) #armo los valores máximos y mínimos para el gráfico
corrmax=max(y2[0],y2[len(y2) -1])
plt.ylim(corrmin,corrmax)
plt.xlabel("Tiempo (s)")
plt.ylabel("Corriente (A)")
plt.title("RL transitorio")
plt.legend()

#calculo el tiempo de carga/descarga característico a partir de las dos señales para compararlos
tauVL=1/popt1[1]
taui=1/popt2[1]
deltatauVL=perr1[1]/popt1[1]*tauVL
deltataui=perr2[1]/popt2[1]*taui
print('Tiempo característico extraído de la tensión de la bobina')
print('tau = (', round(tauVL,5), '+/-',  round(deltatauVL,5), ')s')
print('Tiempo característico extraído de la corriente')
print('tau = (', round(taui,5), '+/-',  round(deltataui,5), ') s')

"""
Descomenten las líneas que siguen si quieren que el programa genere un archivo .txt con los datos obtenidos
"""
#guardo los datos en un archiva de salida
fsalida=open('SalidaRLtransitorio.txt','a')
fsalida.write('%10.9f' %(tauVL)+',')
fsalida.write('%10.9f' % (deltatauVL)+',')
fsalida.write('%8.2f' % (resist)+',')
fsalida.write('%8.2f' % (0.01*resist)+'\n')
fsalida.close()