<jupyter_start><jupyter_text>Lectura y procesamiento de los datos Luego de procesar estos datos se creará un df que contenga el compilado de todos los datos oficiales y blind test en el númeral - Tabla de datos oficiales- Tabla de datos blind<jupyter_code>#Se quiere que este código perdure en el tiempo, por tanto, se genera el código para que lea todos los excel  hasta el año actual
today = date.today()
#Los datos de producción se obtienen desde el año 2013
primeraño=2013
añoactual=today.year
#Un rango de fechas desde el 2013 hasta el año actual
años = range(primeraño,añoactual+1,1)
#Se crea una función para leer los nombres de los archivos que estan ubicados en el directorio
def ls(ruta = Path.cwd()):
    return [arch.name for arch in Path(ruta).iterdir() if arch.is_file()]
#Se establece como ruta una carpeta llamada "Datos" dentro del directorio actual
files=ls("Datos/")
for año in años:
    for file in files:
        añotemp = file[file.find('2'):file.find('2')+4]
        if int(año) == int(añotemp):
            #Se leen los documentos de excel que están en el directorio especificado. Se limita las columnas de la A a la Q
            globals()["año" + str(año)] = pd.read_excel('Datos/'+file,usecols='A:Q')
            #Se eliminan las filas con valores nulos, para así quitar encabezados y totalizadores
            globals()["año" + str(año)]=globals()["año" + str(año)].dropna().reset_index(drop=True)
            #La primera fila pasa a ser el encabezado del data frame
            globals()["año" + str(año)]=globals()["año" + str(año)].rename(columns= globals()["año" + str(año)].iloc[0]).drop(0)
#Dando formato al encabezado
años=[año2013,año2014,año2015,año2016,año2017,año2018,año2019,año2020]
for año in años:
    año.columns = año.columns.str.upper()
    año.columns = año.columns.str.strip()
#Estandarizamos los encabezados para todas las empresas
año2013 = año2013.rename(columns={'EMPRESA': 'OPERADORA'})
año2014 = año2014.rename(columns={'EMPRESA': 'OPERADORA'})
#Eliminando la columna que solo aparece en los años 2013 - 2014
año2013.drop(columns=['CUENCA'],inplace=True)
año2014.drop(columns=['CUENCA'],inplace=True)<jupyter_output><empty_output><jupyter_text>Datos oficiales  1<jupyter_code>#Hago una lista con los nombres de las columnas del dataframe
column2020=año2020.columns
#hallo la posición de la columna que contiene a Enero
for col in range(0,len(column2020)):
    if column2020[col].lower() == 'enero':
        j=col
#Paso de formato wide a long sabiendo cual es la columna que contiene a enero, lugar desde el cual queremos hacer el pivote
table2020 = pd.melt(año2020, id_vars=column2020[0:j], var_name="MES", value_name="ACEITE")
#Agrupo por campo
campo2020 = pd.pivot_table(table2020, values='ACEITE', index=['CAMPO'], aggfunc=np.sum).sort_values(by='ACEITE', ascending=False, na_position='first')
#Al agrupar también ordené de mayor a menor, por tanto el top 5 es igual a las primeras 5 filas
top2020campos=campo2020[0:5]
campo2020
top2020campos
plot = top2020campos.plot(kind='bar', title='Top 5 de campos de mayor producción de petróleo en 2020')<jupyter_output><empty_output><jupyter_text>2<jupyter_code>#Hago una lista con los nombres de las columnas del dataframe
column2018=año2018.columns
#hallo la posición de la columna que contiene a Enero
for col in range(0,len(column2018)):
    if column2018[col].lower() == 'enero':
        j=col
table2018 = pd.melt(año2018, id_vars=column2018[0:j], var_name="MES", value_name="ACEITE")
campo2018 = pd.pivot_table(table2018, values='ACEITE', index=['DEPARTAMENTO','OPERADORA','CAMPO'], aggfunc=np.sum).sort_values(by='ACEITE', ascending=False, na_position='first').reset_index(level='DEPARTAMENTO')
campo2018=campo2018[campo2018['ACEITE']!= 0]
campo2018cas= campo2018[campo2018['DEPARTAMENTO']=='CASANARE'].drop('DEPARTAMENTO',axis=1).reset_index()

campo2018cascount=campo2018cas['OPERADORA'].value_counts().to_frame()
campo2018cascount=campo2018cascount[campo2018cascount['OPERADORA']>=5]
campo2018cascount
plot = campo2018cascount.plot(kind='bar', title='Operadoras que resportaron producción en más de 5 campos de Casanare en 2018')<jupyter_output><empty_output><jupyter_text>3<jupyter_code>contrato2018 = pd.pivot_table(table2018, values='ACEITE', index=['CONTRATO'], aggfunc=np.sum).sort_values(by='ACEITE', ascending=False, na_position='first')
top2018contratos=contrato2018[0:5]/1000000
top2018contratos
plot = top2018contratos.plot(kind='bar', title='Top 5 de contratos de mayor producción de petróleo en 2018')<jupyter_output><empty_output><jupyter_text>4<jupyter_code>column2019=año2019.columns

for col in range(0,len(column2019)):
    if column2018[col].lower() == 'enero':
        j=col
table2019 = pd.melt(año2019, id_vars=column2019[0:j], var_name="MES", value_name="ACEITE")
operadora2019 = pd.pivot_table(table2019, values='ACEITE', index=['OPERADORA','MES'], aggfunc=np.sum).sort_values(by='ACEITE', ascending=False, na_position='first').reset_index(level='MES')
operadora2019ago=operadora2019[operadora2019['MES']=='AGOSTO'].sort_values(by='ACEITE', ascending=False, na_position='first').drop('MES',axis=1)
topoperadora2019ago=operadora2019ago[0:10]
operadora2019
topoperadora2019ago
plot = topoperadora2019ago.plot(kind='bar', title='Top 10 de operadoras con mayor producción de petróleo en agosto de 2019')<jupyter_output><empty_output><jupyter_text>5<jupyter_code>#Lista para realizar el filtro
T1=['enero','febrero','marzo']
T2=['abril','mayo','junio']
#Agrupo por mes
meses2019 = pd.pivot_table(table2019, values='ACEITE', index=['MES'], aggfunc=np.sum).sort_values(by='ACEITE', ascending=False, na_position='first').reset_index(level='MES')
#Aplico formato al texto para realizar el filtro correctamente 
meses2019['MES']=meses2019['MES'].apply(lambda x: x.lower())
#Aplico los filtros de los trimestres y guardo los resultados
T12019=meses2019[meses2019['MES'].isin(T1)].reset_index(drop=True)
T22019=meses2019[meses2019['MES'].isin(T2)].reset_index(drop=True)
#Agrupo por mes
meses2020 = pd.pivot_table(table2020, values='ACEITE', index=['MES'], aggfunc=np.sum).sort_values(by='ACEITE', ascending=False, na_position='first').reset_index(level='MES')
#Aplico formato al texto para realizar el filtro correctamente 
meses2020['MES']=meses2020['MES'].apply(lambda x: x.lower())
#Aplico los filtros de los trimestres y guardo los resultados
T12020=meses2020[meses2020['MES'].isin(T1)].reset_index(drop=True)
T22020=meses2020[meses2020['MES'].isin(T2)].reset_index(drop=True)
#Genero un data frame para guardas los resultados de los filtros y agrupaciones
trim1920 = pd.DataFrame({"Año": [2019,2020], "Trimestre 1": [T12019['ACEITE'].sum(),T12020['ACEITE'].sum()], "Trimestre 2": [T22019['ACEITE'].sum(),T22020['ACEITE'].sum()]})
#Subo a indice la columna año
trim1920.set_index("Año")
coloresMedallas = ['#FFD700','#C0C0C0']

trim1920.plot(kind = 'bar',
             width=0.8,
             figsize=(10,4),
             color = coloresMedallas);<jupyter_output><empty_output><jupyter_text>Tabla de datos oficiales<jupyter_code>#Generando las tablas no usadas en los puntos anteriores
#Hago una lista con los nombres de las columnas del dataframe
column2013=año2013.columns
column2014=año2014.columns
column2015=año2015.columns
column2016=año2016.columns
column2017=año2017.columns
#hallo la posición de la columna que contiene a Enero
for col in range(0,len(column2013)):
    if column2013[col].lower() == 'enero':
        j=col
#Paso de formato wide a long sabiendo cual es la columna que contiene a enero, lugar desde el cual queremos hacer el pivote
table2013 = pd.melt(año2013, id_vars=column2013[0:j], var_name="MES", value_name="ACEITE")
for col in range(0,len(column2014)):
    if column2014[col].lower() == 'enero':
        j=col
table2014 = pd.melt(año2014, id_vars=column2014[0:j], var_name="MES", value_name="ACEITE")
for col in range(0,len(column2015)):
    if column2015[col].lower() == 'enero':
        j=col
table2015 = pd.melt(año2015, id_vars=column2015[0:j], var_name="MES", value_name="ACEITE")
for col in range(0,len(column2016)):
    if column2016[col].lower() == 'enero':
        j=col
table2016 = pd.melt(año2015, id_vars=column2016[0:j], var_name="MES", value_name="ACEITE")
for col in range(0,len(column2017)):
    if column2017[col].lower() == 'enero':
        j=col
table2017 = pd.melt(año2017, id_vars=column2017[0:j], var_name="MES", value_name="ACEITE")
#Juntaré los 3 años en un data frame, para esto, voy a diferenciarlos por el año
table2013['YYYY'] = 2013
table2014['YYYY'] = 2014
table2015['YYYY'] = 2015
table2016['YYYY'] = 2016
table2017['YYYY'] = 2017
table2018['YYYY'] = 2018
table2019['YYYY'] = 2019
table2020['YYYY'] = 2020
#Ahora convertiré el mes a número para tener datos secuenciales MM-YYYY
def mesnum(mes):
    if mes.lower().strip() == 'enero':
        mesn = 1 
    if mes.lower().strip() == 'febrero':
        mesn = 2 
    if mes.lower().strip() == 'marzo':
        mesn = 3
    if mes.lower().strip() == 'abril':
        mesn = 4 
    if mes.lower().strip() == 'mayo':
        mesn = 5 
    if mes.lower().strip() == 'junio':
        mesn = 6
    if mes.lower().strip() == 'julio':
        mesn = 7 
    if mes.lower().strip() == 'agosto':
        mesn = 8 
    if mes.lower().strip() == 'septiembre':
        mesn = 9
    if mes.lower().strip() == 'octubre':
        mesn = 10 
    if mes.lower().strip() == 'noviembre':
        mesn = 11
    if mes.lower().strip() == 'diciembre':
        mesn = 12
    return mesn

table2013['MM'] = table2013['MES'].apply(mesnum)
table2014['MM'] = table2014['MES'].apply(mesnum)
table2015['MM'] = table2015['MES'].apply(mesnum)
table2016['MM'] = table2016['MES'].apply(mesnum)
table2017['MM'] = table2017['MES'].apply(mesnum)
table2018['MM'] = table2018['MES'].apply(mesnum)
table2019['MM'] = table2019['MES'].apply(mesnum)
table2020['MM'] = table2020['MES'].apply(mesnum)

#Concateno el mes y el año
def concat(*args):
    strs = [str(arg) for arg in args if not pd.isnull(arg)]
    return '/'.join(strs) if strs else np.nan
np_concat = np.vectorize(concat)

table2013['MM-YYYY'] = np_concat(table2013['MM'], table2013['YYYY'])
table2014['MM-YYYY'] = np_concat(table2014['MM'], table2014['YYYY'])
table2015['MM-YYYY'] = np_concat(table2015['MM'], table2015['YYYY'])
table2016['MM-YYYY'] = np_concat(table2016['MM'], table2016['YYYY'])
table2017['MM-YYYY'] = np_concat(table2017['MM'], table2017['YYYY'])
table2018['MM-YYYY'] = np_concat(table2018['MM'], table2018['YYYY'])
table2019['MM-YYYY'] = np_concat(table2019['MM'], table2019['YYYY'])
table2020['MM-YYYY'] = np_concat(table2020['MM'], table2020['YYYY'])

#Realizo formato de fecha
table2013['FECHA'] = table2013['MM-YYYY'].apply(lambda x: datetime.strptime(x, '%m/%Y'))
table2014['FECHA'] = table2014['MM-YYYY'].apply(lambda x: datetime.strptime(x, '%m/%Y'))
table2015['FECHA'] = table2015['MM-YYYY'].apply(lambda x: datetime.strptime(x, '%m/%Y'))
table2016['FECHA'] = table2016['MM-YYYY'].apply(lambda x: datetime.strptime(x, '%m/%Y'))
table2017['FECHA'] = table2017['MM-YYYY'].apply(lambda x: datetime.strptime(x, '%m/%Y'))
table2018['FECHA'] = table2018['MM-YYYY'].apply(lambda x: datetime.strptime(x, '%m/%Y'))
table2019['FECHA'] = table2019['MM-YYYY'].apply(lambda x: datetime.strptime(x, '%m/%Y'))
table2020['FECHA'] = table2020['MM-YYYY'].apply(lambda x: datetime.strptime(x, '%m/%Y'))

#Borraré las columnas que creé para genera la fecha
table2013.drop([ 'MM','MM-YYYY'], axis = 'columns', inplace=True)
table2014.drop(['MM','MM-YYYY'], axis = 'columns', inplace=True)
table2015.drop([ 'MM','MM-YYYY'], axis = 'columns', inplace=True)
table2016.drop([ 'MM','MM-YYYY'], axis = 'columns', inplace=True)
table2017.drop([ 'MM','MM-YYYY'], axis = 'columns', inplace=True)
table2018.drop([ 'MM','MM-YYYY'], axis = 'columns', inplace=True)
table2019.drop([ 'MM','MM-YYYY'], axis = 'columns', inplace=True)
table2020.drop([ 'MM','MM-YYYY'], axis = 'columns', inplace=True)

#Dejamos todos los años en un solo df
table_comp= pd.concat([table2013,table2014,table2015,table2016,table2017,table2018,table2019,table2020], ignore_index=True).fillna("No encontrado")
table2016['ACEITE'].sum()<jupyter_output><empty_output><jupyter_text>Blind data El script de lectura es el mismo que el usado para los datos oficiales, solo cambia el directorio de trabajo<jupyter_code>#Se quiere que este código perdure en el tiempo, por tanto, se genera el código para que lea todos los excel  hasta el año actual
today = date.today()
#Los datos de producción se obtienen desde el año 2013
primeraño=2013
añoactual=today.year
#Un rango de fechas desde el 2013 hasta el año actual
años = range(primeraño,añoactual+1,1)
#Se crea una función para leer los nombres de los archivos que estan ubicados en el directorio
def ls(ruta = Path.cwd()):
    return [arch.name for arch in Path(ruta).iterdir() if arch.is_file()]
#Se establece como ruta una carpeta llamada "Datos/Blind data/" dentro del directorio actual
files=ls("Datos/Blind data/")
for año in años:
    for file in files:
        añotemp = file[file.find('2'):file.find('2')+4]
        if int(año) == int(añotemp):
            #Se leen los documentos de excel que están en el directorio especificado. Se limita las columnas de la A a la Q
            globals()["blindaño" + str(año)] = pd.read_excel('Datos/Blind data/'+file,usecols='A:Q')
            #Se eliminan las filas con valores nulos, para así quitar encabezados y totalizadores
            globals()["blindaño" + str(año)]=globals()["blindaño" + str(año)].dropna().reset_index(drop=True)<jupyter_output><empty_output><jupyter_text>6<jupyter_code>#Hago una lista con los nombres de las columnas del dataframe
blind_column2019=blindaño2019.columns
#hallo la posición de la columna que contiene a Enero
for col in range(0,len(blind_column2019)):
    if blind_column2019[col].lower() == 'enero':
        j=col
#Paso de formato wide a long sabiendo cual es la columna que contiene a enero, lugar desde el cual queremos hacer el pivote
blind_table2019 = pd.melt(blindaño2019, id_vars=blind_column2019[0:j], var_name="MES", value_name="ACEITE")
#Si se desea inspeccionar otro campo y otro mes, solo debe cambiar estas variables
campo='1f d2689f'
mes='JULIO'
campo2019_7 = blind_table2019[blind_table2019['CAMPO']==campo.lower()][blind_table2019['MES']==mes.upper()].reset_index(drop=True)
print('Caudal de producción del campo', campo.upper(), 'en Julio de 2019:',campo2019_7['ACEITE'][0])
blind_table2019[blind_table2019['CAMPO']==campo.lower()]
by_field=sns.barplot(x='MES', y='ACEITE', hue='CAMPO', data=blind_table2019[blind_table2019['CAMPO']==campo.lower()], palette=sns.color_palette("RdBu", n_colors=7))
for item in by_field.get_xticklabels():
    item.set_rotation(45)<jupyter_output><empty_output><jupyter_text>7<jupyter_code>#Si se desea inspeccionar otro campo y otro mes, solo debe cambiar estas variables
operadora = '2fe52430'
mes = 'FEBRERO'
operadora2019_2 = blind_table2019[blind_table2019['OPERADORA']==operadora.lower()][blind_table2019['MES']==mes.upper()].reset_index(drop=True)
print('Caudal de producción de la operadora', operadora.upper(), 'en Febrero de 2019:',operadora2019_2['ACEITE'].sum())
blind_table2019[blind_table2019['OPERADORA']==operadora.lower()][blind_table2019['MES']==mes.upper()]
by_field=sns.barplot(x='CAMPO', y='ACEITE', hue='MES', data=blind_table2019[blind_table2019['OPERADORA']==operadora.lower()][blind_table2019['MES']==mes.upper()], palette=sns.color_palette("RdBu", n_colors=7))
for item in by_field.get_xticklabels():
    item.set_rotation(45)<jupyter_output><empty_output><jupyter_text>8<jupyter_code>#Hago una lista con los nombres de las columnas del dataframe
blind_column2018=blindaño2018.columns
#hallo la posición de la columna que contiene a Enero
for col in range(0,len(blind_column2018)):
    if blind_column2018[col].lower() == 'enero':
        j=col
#Paso de formato wide a long sabiendo cual es la columna que contiene a enero, lugar desde el cual queremos hacer el pivote
blind_table2018 = pd.melt(blindaño2018, id_vars=blind_column2018[0:j], var_name="MES", value_name="ACEITE")
#Agrupo por departamento
departamento2018 = pd.pivot_table(blind_table2018, values='ACEITE', index=['DEPARTAMENTO'], aggfunc=np.sum).sort_values(by='ACEITE', na_position='first').reset_index()
departamento2018
by_field=sns.barplot(x='DEPARTAMENTO', y='ACEITE', data=departamento2018, palette=sns.color_palette("RdBu", n_colors=7))
for item in by_field.get_xticklabels():
    item.set_rotation(45)<jupyter_output><empty_output><jupyter_text>9<jupyter_code>#Hago una lista con los nombres de las columnas del dataframe
blind_column2017=blindaño2017.columns
#hallo la posición de la columna que contiene a Enero
for col in range(0,len(blind_column2017)):
    if blind_column2017[col].lower() == 'enero':
        j=col
#Paso de formato wide a long sabiendo cual es la columna que contiene a enero, lugar desde el cual queremos hacer el pivote
blind_table2017 = pd.melt(blindaño2017, id_vars=blind_column2017[0:j], var_name="MES", value_name="ACEITE")<jupyter_output><empty_output><jupyter_text>Tabla de datos blind<jupyter_code>#Juntaré los 3 años en un data frame, para esto, voy a diferenciarlos por el año
blind_table2017['YYYY'] = 2017
blind_table2018['YYYY'] = 2018
blind_table2019['YYYY'] = 2019
#Ahora convertiré el mes a número para tener datos secuenciales MM-YYYY
def mesnum(mes):
    if mes.lower() == 'enero':
        mesn = 1 
    if mes.lower() == 'febrero':
        mesn = 2 
    if mes.lower() == 'marzo':
        mesn = 3
    if mes.lower() == 'abril':
        mesn = 4 
    if mes.lower() == 'mayo':
        mesn = 5 
    if mes.lower() == 'junio':
        mesn = 6
    if mes.lower() == 'julio':
        mesn = 7 
    if mes.lower() == 'agosto':
        mesn = 8 
    if mes.lower() == 'septiembre':
        mesn = 9
    if mes.lower() == 'octubre':
        mesn = 10 
    if mes.lower() == 'noviembre':
        mesn = 11
    if mes.lower() == 'diciembre':
        mesn = 12
    return mesn

blind_table2017['MM'] = blind_table2017['MES'].apply(mesnum)
blind_table2018['MM'] = blind_table2018['MES'].apply(mesnum)
blind_table2019['MM'] = blind_table2019['MES'].apply(mesnum)

#Concateno el mes y el año
def concat(*args):
    strs = [str(arg) for arg in args if not pd.isnull(arg)]
    return '/'.join(strs) if strs else np.nan
np_concat = np.vectorize(concat)
 
blind_table2017['MM-YYYY'] = np_concat(blind_table2017['MM'], blind_table2017['YYYY'])
blind_table2018['MM-YYYY'] = np_concat(blind_table2018['MM'], blind_table2018['YYYY'])
blind_table2019['MM-YYYY'] = np_concat(blind_table2019['MM'], blind_table2019['YYYY'])

#Realizo formato de fecha
blind_table2017['FECHA'] = blind_table2017['MM-YYYY'].apply(lambda x: datetime.strptime(x, '%m/%Y'))
blind_table2018['FECHA'] = blind_table2018['MM-YYYY'].apply(lambda x: datetime.strptime(x, '%m/%Y'))
blind_table2019['FECHA'] = blind_table2019['MM-YYYY'].apply(lambda x: datetime.strptime(x, '%m/%Y'))

#Borraré las columnas que creé para genera la fecha excepto año, la cual usaré para solucionar este punto
blind_table2017.drop(['MES','MM','MM-YYYY'], axis = 'columns', inplace=True)
blind_table2018.drop(['MES','MM','MM-YYYY'], axis = 'columns', inplace=True)
blind_table2019.drop(['MES','MM','MM-YYYY'], axis = 'columns', inplace=True)

#Dejamos todos los años en un solo df
blind_table_comp= pd.concat([blind_table2017, blind_table2018, blind_table2019], ignore_index=True)
blind_table_comp
depcampo = pd.pivot_table(blind_table_comp, values='ACEITE', index=['DEPARTAMENTO','CAMPO','YYYY'], aggfunc=np.mean).sort_values(by='ACEITE', ascending=False, na_position='first').reset_index()
depcampo.drop(columns=['CAMPO','YYYY'],inplace=True)
summary_blind_table=depcampo.groupby('DEPARTAMENTO').describe().unstack(1)
print(summary_blind_table)
sns.set_theme(style="whitegrid")
ax = sns.violinplot(x="DEPARTAMENTO", y="ACEITE", 
                    data=depcampo, palette="muted")<jupyter_output><empty_output><jupyter_text>Según los valores de desviación estandar, y el "violin plot" se observa claramente que el departamento cf33cb8a es el que tiene mayor variación en la producción promedio anual.  10<jupyter_code>blind_table_comp.drop(['YYYY'], axis = 'columns', inplace=True)
#Grafica de los datos de producción en el tiempo Nota: Se realiza para que pueda ser graficado distintos campos al tiempo
def RegularPlot(df, wells, units):
    fig, ax = plt.subplots(figsize=(15,8))
    plt.xlabel('Fecha')
    plt.ylabel('ACEITE '+ units)
    for well in wells:
        df_filtered = df[df['CAMPO']==well]
        rate = df_filtered['ACEITE']
        date = df_filtered['FECHA']
        ax.plot(date, rate, 'o', label=well)
    ax.legend(shadow=True, fancybox=True)
    return plt
#Se normaliza la grafica anterior con pasos mensuales

def NormalisedData(df, wells):
    norm_data = {}
    for well in wells:
        df_filtered = df[df['CAMPO']==well]
        start_date = min(df_filtered['FECHA'])
        rate = df_filtered['ACEITE']
        time = df_filtered['FECHA'] - start_date
        time = time.dt.days
        norm_data[well] = {
            'rate': rate,
            'time': time
        }
    return norm_data

def NormalisedPlot(df, wells):
    fig, ax = plt.subplots(figsize=(15, 8))
    plt.xlabel('DIAS')
    plt.ylabel('ACEITE')
    for well in wells:
        df_filtered = df[df['CAMPO']==well]
        start_date = min(df_filtered['FECHA'])
        rate = df_filtered['ACEITE']
        time = df_filtered['FECHA'] - start_date
        time = time.dt.days
        ax.plot(time, rate, 'o', label=well)
    ax.legend(shadow=True, fancybox=True)
    return plt
campo = ['51cbb05d']
dfcampo = blind_table_comp.drop(columns=['DEPARTAMENTO','MUNICIPIO','OPERADORA','CONTRATO']).reset_index(drop=True)
dfcampo
plot_data = RegularPlot (dfcampo, campo, 'BOPM')
normalised_data = NormalisedData(dfcampo, campo)
normalised_plot = NormalisedPlot(dfcampo, campo)
#Se dejará todo expresado de tal manera que si quiere realizar un tiempo de prueba y otro tiempo de testeo de la ecuación, solo deba cambiar "datat" y quitar el númeral de las dos lineas de código comentada
#Esto se hace ya que es algo común en métodos de machine learning
def arps(t, initial_rate, decline): 
    #Definimos la función de ARPS
    #Declinación hiperbolica con b=0.5
    values = initial_rate / ((1 + 0.5 * decline * t) ** (1 / 0.5))      
    return values
#Haremos un ajuste de una curva a la ecuación de arps con los datos de producción.
#Se harán dos escenarios, tomando como tasa inicial el mayor dato de producción y otra dejando que el ajuste la elija
fitdict1={}
for well in campo:
    #Leemos los datos normalizados de mes y producción
    X_p = normalised_data[well]['time']        
    Y_p = normalised_data[well]['rate']
    X_arps=X_p[:int(len(X_p))]           
    Y_arps=Y_p[:int(len(Y_p))]
    #Se lee la mayor la tasa de producción
    Maxrate=max(Y_arps)   
    #Se realiza un ajuste a la ecuación de Arps 
    fitdict1[well]={
    popt, pcov = curve_fit(arps, X_arps, Y_arps, bounds=([0, 0],[Maxrate, 0.1]))    
      'initial rate': popt[0],
      'decline rate': popt[1] 
    }
datat=0
time_predict=[]
rate_predict=[]
arps_predict={}
for well in campo:
    #Acá es donde se supone que hará un "split data"
    X_p = normalised_data[well]['time']
    time_train=X_p[:int(len(X_p)*datat)]   
    time_predict=X_p[int(len(X_p)*datat):]   
    Y_p = normalised_data[well]['rate']
    rate_test=Y_p[int(len(Y_p)*datat):]
    #Con los parametros ajustados en el ciclo pasado, generamos la curva de ARPS
    for time in time_predict:
        rate_predict=arps(time_predict, fitdict1[well]['initial rate'], fitdict[well]['decline rate'])
        #rate_train=arps(time_train, fitdict[well]['beta'], fitdict[well]['initial rate'], fitdict[well]['decline rate'])
    arps_predict[well]={
        'time':time_predict,
        'rate':rate_predict
    }
    plt.scatter(X_p, Y_p)
    plt.plot(time_predict, rate_predict, color='green', linewidth=3)
    #plt.plot(time_train, rate_train, color='red', linewidth=3)
    plt.xlabel('Days')
    plt.ylabel('Rate')
    plt.title('Arps equation')
    plt.show()
def arps(t, decline):   #Definimos la función de ARPS
        #Declinación hiperbolica
        #Acá hacemos uso de la tasa que se halló en el método pasado para fijar la tasa inicial
    values = Maxrate / ((1 + 0.5 * decline * t) ** (1 / 0.5))      
    return values

fitdict2={}
for well in campo:
    X_p = normalised_data[well]['time']        
    Y_p = normalised_data[well]['rate']
    X_arps=X_p[:int(len(X_p))]           
    Y_arps=Y_p[:int(len(Y_p))]
                       
    popt, pcov = curve_fit(arps, X_arps, Y_arps, bounds=([0],[0.1]))    #Se realiza un ajuste a la ecuación de Arps usando esos limites y los datos de entrenamiento
    fitdict2[well]={
      
      'decline rate': popt[0] 
    }
datat=0
time_predict=[]
rate_predict=[]
arps_predict={}
for well in campo:
    X_p = normalised_data[well]['time']
    time_train=X_p[:int(len(X_p)*datat)]   
    time_predict=X_p[int(len(X_p)*datat):]    #20% de los datos como prueba
    Y_p = normalised_data[well]['rate']
    rate_test=Y_p[int(len(Y_p)*datat):]
    for time in time_predict:
        rate_predict=arps(time_predict, fitdict2[well]['decline rate'])
        #rate_train=arps(time_train, fitdict[well]['beta'], fitdict[well]['initial rate'], fitdict[well]['decline rate'])
    arps_predict[well]={
        'time':time_predict,
        'rate':rate_predict
    }
    plt.scatter(X_p, Y_p)
    plt.plot(time_predict, rate_predict, color='green', linewidth=3)
    #plt.plot(time_train, rate_train, color='red', linewidth=3)
    plt.xlabel('Days')
    plt.ylabel('Rate')
    plt.title('Arps equation')
    plt.show()
print('Se dejan dos tasas de declinación para que a consideración del lector elija la que considere correcta')
print('Por el primer método (Tasa inicial variable) se tiene una tasa de declinación de',fitdict1['51cbb05d']['decline rate'])
print('Por el segundo método (Tasa inicial fija) se tiene una tasa de declinación de',fitdict2['51cbb05d']['decline rate'])<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1447740652955119, 'fraction_numerical': 0.056885082957412646, 'mean_word_length': 5.23724368144969, 'pattern_counts': {'":': 3, '<': 57, '<?xml version=': 0, '>': 58, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '14', 'dir': 'jupyter-structured-clean-dedup', 'id': '93199', 'license': 'MIT', 'n_tokens_mistral': 10639, 'n_tokens_neox': 9481, 'n_words': 2215, 'path': 'Datos Notebooks desarrollo/Hackaton SPE.ipynb', 'repo_name': 'danielsantiago1002/Hackaton-SPE-2020', 'size': '26158'}