Update app.py

app.py

@@ -10,44 +10,8 @@ from docx.shared import Inches, Pt
 from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
 import os
 
-def generar_tabla(n_filas, concentracion_inicial, unidad_medida, n_replicas):
-    valores_base = [1.000, 0.800, 0.600, 0.400, 0.200, 0.100, 0.050]
-
-    if n_filas <= 7:
-        solucion_inoculo = valores_base[:n_filas]
-        agua = [round(1 - x, 3) for x in solucion_inoculo]
-    else:
-        solucion_inoculo = valores_base.copy()
-        ultimo_valor = valores_base[-1]
-        for _ in range(n_filas - 7):
-            nuevo_valor = round(ultimo_valor / 2, 3)
-            solucion_inoculo.append(nuevo_valor)
-            ultimo_valor = nuevo_valor
-        agua = [round(1 - x, 3) for x in solucion_inoculo]
-
-    data = {
-        f"Solución de inóculo ({concentracion_inicial} {unidad_medida})": solucion_inoculo,
-        "H2O": agua
-    }
-    df = pd.DataFrame(data)
-
-    nombre_columna = f"Solución de inóculo ({concentracion_inicial} {unidad_medida})"
-    df["Factor de Dilución"] = df[nombre_columna].apply(lambda x: round(1 / x, 3))
-    df["Concentración Predicha Numérica"] = df["Factor de Dilución"].apply(
-        lambda x: concentracion_inicial / x
-    )
-    df[f"Concentración Predicha ({unidad_medida})"] = df["Concentración Predicha Numérica"].round(3).astype(str)
-
-    # Añadir columnas para las réplicas de "Concentración Real"
-    for i in range(1, n_replicas + 1):
-        df[f"Concentración Real {i} ({unidad_medida})"] = None
-
-    # Las columnas de promedio y desviación estándar se agregarán durante el análisis
-    return df
-
 def ajustar_decimales_evento(df, decimales):
     df = df.copy()
-    # Ajustar decimales en todas las columnas numéricas
     for col in df.columns:
         try:
             df[col] = pd.to_numeric(df[col], errors='ignore')
@@ -58,21 +22,20 @@ def ajustar_decimales_evento(df, decimales):
 
 def calcular_promedio_desviacion(df, n_replicas, unidad_medida, decimales):
     df = df.copy()
-    # Obtener las columnas de réplicas
-    col_replicas = [f"Concentración Real {i} ({unidad_medida})" for i in range(1, n_replicas + 1)]
-    # Convertir a numérico
+    col_replicas = [c for c in df.columns if c.startswith("Concentración Real") and unidad_medida in c and "Promedio" not in c and "Desviación" not in c]
     for col in col_replicas:
         df[col] = pd.to_numeric(df[col], errors='coerce')
 
-    # Calcular el promedio y la desviación estándar
-    df[f"Concentración Real Promedio ({unidad_medida})"] = df[col_replicas].mean(axis=1)
+    if len(col_replicas) > 0:
+        df[f"Concentración Real Promedio ({unidad_medida})"] = df[col_replicas].mean(axis=1)
+    else:
+        df[f"Concentración Real Promedio ({unidad_medida})"] = np.nan
 
-    if n_replicas > 1:
+    if len(col_replicas) > 1:
         df[f"Desviación Estándar ({unidad_medida})"] = df[col_replicas].std(ddof=1, axis=1)
     else:
         df[f"Desviación Estándar ({unidad_medida})"] = 0.0
 
-    # Redondear al número de decimales especificado
     df[f"Concentración Real Promedio ({unidad_medida})"] = df[f"Concentración Real Promedio ({unidad_medida})"].round(decimales)
     df[f"Desviación Estándar ({unidad_medida})"] = df[f"Desviación Estándar ({unidad_medida})"].round(decimales)
 
@@ -86,37 +49,35 @@ def generar_graficos(df_valid, n_replicas, unidad_medida, palette_puntos, estilo
     col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
     col_desviacion = f"Desviación Estándar ({unidad_medida})"
 
-    # Convertir a numérico
-    df_valid[col_predicha_num] = df_valid[col_predicha_num].astype(float)
-    df_valid[col_real_promedio] = df_valid[col_real_promedio].astype(float)
-    df_valid[col_desviacion] = df_valid[col_desviacion].fillna(0).astype(float)
+    df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
+    df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
+    df_valid[col_desviacion] = pd.to_numeric(df_valid[col_desviacion], errors='coerce').fillna(0)
+
+    if df_valid.empty or df_valid[col_predicha_num].isna().all() or df_valid[col_real_promedio].isna().all():
+        fig = plt.figure()
+        plt.text(0.5,0.5,"Datos insuficientes para generar el gráfico",ha='center',va='center')
+        return fig
 
-    # Calcular regresión lineal
     slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
     df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
 
-    # Configurar estilos
     sns.set(style="whitegrid")
     plt.rcParams.update({'figure.autolayout': True})
 
     fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
 
-    # Obtener colores de las paletas
     colors_puntos = sns.color_palette(palette_puntos, as_cmap=False)
     colors_linea_ajuste = sns.color_palette(palette_linea_ajuste, as_cmap=False)
     colors_linea_ideal = sns.color_palette(palette_linea_ideal, as_cmap=False)
     colors_barras_error = sns.color_palette(palette_barras_error, as_cmap=False)
 
-    # Seleccionar colores
     color_puntos = colors_puntos[0]
     color_linea_ajuste = colors_linea_ajuste[0]
     color_linea_ideal = colors_linea_ideal[0]
     color_barras_error = colors_barras_error[0]
 
-    # Gráfico de dispersión con línea de regresión
     if mostrar_puntos:
         if n_replicas > 1:
-            # Incluir barras de error
             ax1.errorbar(
                 df_valid[col_predicha_num],
                 df_valid[col_real_promedio],
@@ -138,7 +99,6 @@ def generar_graficos(df_valid, n_replicas, unidad_medida, palette_puntos, estilo
                 marker=estilo_puntos
             )
 
-    # Línea de ajuste
     if mostrar_linea_ajuste:
         ax1.plot(
             df_valid[col_predicha_num],
@@ -149,7 +109,6 @@ def generar_graficos(df_valid, n_replicas, unidad_medida, palette_puntos, estilo
             linestyle=estilo_linea_ajuste
         )
 
-    # Línea ideal
     if mostrar_linea_ideal:
         min_predicha = df_valid[col_predicha_num].min()
         max_predicha = df_valid[col_predicha_num].max()
@@ -165,7 +124,6 @@ def generar_graficos(df_valid, n_replicas, unidad_medida, palette_puntos, estilo
     ax1.set_xlabel('Concentración Predicha', fontsize=12)
     ax1.set_ylabel('Concentración Real Promedio', fontsize=12)
 
-    # Añadir ecuación y R² en el gráfico
     ax1.annotate(
         f'y = {intercept:.3f} + {slope:.3f}x\n$R^2$ = {r_value**2:.4f}',
         xy=(0.05, 0.95),
@@ -175,10 +133,8 @@ def generar_graficos(df_valid, n_replicas, unidad_medida, palette_puntos, estilo
         verticalalignment='top'
     )
 
-    # Posicionar la leyenda
     ax1.legend(loc='lower right', fontsize=10)
 
-    # Gráfico de residuos
     residuos = df_valid[col_real_promedio] - df_valid['Ajuste Lineal']
     ax2.scatter(
         df_valid[col_predicha_num],
@@ -196,11 +152,10 @@ def generar_graficos(df_valid, n_replicas, unidad_medida, palette_puntos, estilo
     ax2.legend(loc='upper right', fontsize=10)
 
     plt.tight_layout()
-    plt.savefig('grafico.png')  # Guardar el gráfico para incluirlo en el informe
+    plt.savefig('grafico.png')  
     return fig
 
 def evaluar_calidad_calibracion(df_valid, r_squared, rmse, cv_percent):
-    """Evaluar la calidad de la calibración y proporcionar recomendaciones"""
     evaluacion = {
         "calidad": "",
         "recomendaciones": [],
@@ -222,27 +177,30 @@ def evaluar_calidad_calibracion(df_valid, r_squared, rmse, cv_percent):
     if cv_percent > 15:
         evaluacion["recomendaciones"].append("- La variabilidad es alta. Revise el procedimiento de dilución")
 
-    if rmse > 0.1 * df_valid[df_valid.columns[-1]].astype(float).mean():
+    mean_val = df_valid[df_valid.columns[-1]].astype(float).mean() if not df_valid.empty else 1
+    if mean_val == 0:
+        mean_val = 1
+    if rmse > 0.1 * mean_val:
         evaluacion["recomendaciones"].append("- El error de predicción es significativo. Verifique la técnica de medición")
 
     return evaluacion
 
 def generar_informe_completo(df_valid, n_replicas, unidad_medida):
-    """Generar un informe completo en formato markdown"""
     col_predicha_num = "Concentración Predicha Numérica"
     col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
-    # Convertir a numérico
-    df_valid[col_predicha_num] = df_valid[col_predicha_num].astype(float)
-    df_valid[col_real_promedio] = df_valid[col_real_promedio].astype(float)
+    df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
+    df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
+
+    if len(df_valid) < 2:
+        informe = "# Informe de Calibración ⚠️\nNo hay suficientes datos para calcular la regresión."
+        return informe, "⚠️"
 
-    # Calcular estadísticas
     slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
     r_squared = r_value ** 2
     rmse = np.sqrt(((df_valid[col_real_promedio] - (intercept + slope * df_valid[col_predicha_num])) ** 2).mean())
-    cv = (df_valid[col_real_promedio].std() / df_valid[col_real_promedio].mean()) * 100  # CV de los valores reales
+    cv = (df_valid[col_real_promedio].std() / df_valid[col_real_promedio].mean()) * 100 if df_valid[col_real_promedio].mean() != 0 else 0
 
-    # Evaluar calidad
     evaluacion = evaluar_calidad_calibracion(df_valid, r_squared, rmse, cv)
 
     informe = f"""# Informe de Calibración {evaluacion['estado']}
@@ -275,38 +233,30 @@ def actualizar_analisis(df, n_replicas, unidad_medida, filas_seleccionadas, deci
     if df is None or df.empty:
         return "Error en los datos", None, "No se pueden generar análisis", df
 
-    # Convertir filas_seleccionadas a índices
     if not filas_seleccionadas:
         return "Se necesitan más datos", None, "No se han seleccionado filas para el análisis", df
 
     indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas]
 
-    # Calcular promedio y desviación estándar dependiendo de las réplicas
     df = calcular_promedio_desviacion(df, n_replicas, unidad_medida, decimales)
 
     col_predicha_num = "Concentración Predicha Numérica"
     col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
-    # Convertir columnas a numérico
     df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
     df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
 
     df_valid = df.dropna(subset=[col_predicha_num, col_real_promedio])
-
-    # Resetear el índice para asegurar que sea secuencial
     df_valid.reset_index(drop=True, inplace=True)
 
-    # Filtrar filas según las seleccionadas
     df_valid = df_valid.loc[indices_seleccionados]
 
     if len(df_valid) < 2:
         return "Se necesitan más datos", None, "Se requieren al menos dos valores reales para el análisis", df
 
-    # Calcular la regresión y agregar 'Ajuste Lineal'
     slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
     df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
 
-    # Generar gráfico con opciones predeterminadas
     fig = generar_graficos(
         df_valid, n_replicas, unidad_medida,
         palette_puntos='deep', estilo_puntos='o',
@@ -314,7 +264,7 @@ def actualizar_analisis(df, n_replicas, unidad_medida, filas_seleccionadas, deci
         palette_linea_ideal='bright', estilo_linea_ideal='--',
         palette_barras_error='pastel',
         mostrar_linea_ajuste=True,
-        mostrar_linea_ideal=False,  # Línea Ideal desmarcada por defecto
+        mostrar_linea_ideal=False,
         mostrar_puntos=True
     )
     informe, estado = generar_informe_completo(df_valid, n_replicas, unidad_medida)
@@ -331,34 +281,26 @@ def actualizar_graficos(df, n_replicas, unidad_medida,
     if df is None or df.empty:
         return None
 
-    # Asegurarse de que los cálculos estén actualizados
     df = calcular_promedio_desviacion(df, n_replicas, unidad_medida, decimales)
 
     col_predicha_num = "Concentración Predicha Numérica"
     col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
-    # Convertir columnas a numérico
     df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
     df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
 
     df_valid = df.dropna(subset=[col_predicha_num, col_real_promedio])
-
-    # Resetear el índice para asegurar que sea secuencial
     df_valid.reset_index(drop=True, inplace=True)
 
-    # Convertir filas_seleccionadas a índices
     if not filas_seleccionadas:
         return None
 
     indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas]
-
-    # Filtrar filas según las seleccionadas
     df_valid = df_valid.loc[indices_seleccionados]
 
     if len(df_valid) < 2:
         return None
 
-    # Generar gráfico con opciones seleccionadas
     fig = generar_graficos(
         df_valid, n_replicas, unidad_medida,
         palette_puntos, estilo_puntos,
@@ -371,36 +313,28 @@ def actualizar_graficos(df, n_replicas, unidad_medida,
     return fig
 
 def exportar_informe_word(df_valid, informe_md, unidad_medida):
-    # Crear documento Word
     doc = docx.Document()
 
-    # Estilos APA 7
     style = doc.styles['Normal']
     font = style.font
     font.name = 'Times New Roman'
     font.size = Pt(12)
 
-    # Título centrado
     titulo = doc.add_heading('Informe de Calibración', 0)
     titulo.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
 
-    # Fecha
     fecha = doc.add_paragraph(f"Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}")
     fecha.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
 
-    # Insertar gráfico
     if os.path.exists('grafico.png'):
         doc.add_picture('grafico.png', width=Inches(6))
         ultimo_parrafo = doc.paragraphs[-1]
         ultimo_parrafo.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
-
-        # Leyenda del gráfico en estilo APA 7
         leyenda = doc.add_paragraph('Figura 1. Gráfico de calibración.')
         leyenda_format = leyenda.paragraph_format
         leyenda_format.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
         leyenda.style = doc.styles['Caption']
 
-    # Agregar contenido del informe
     doc.add_heading('Resumen Estadístico', level=1)
     for linea in informe_md.split('\n'):
         if linea.startswith('##'):
@@ -408,43 +342,34 @@ def exportar_informe_word(df_valid, informe_md, unidad_medida):
         else:
             doc.add_paragraph(linea)
 
-    # Añadir tabla de datos
     doc.add_heading('Tabla de Datos de Calibración', level=1)
-
-    # Convertir DataFrame a lista de listas
     tabla_datos = df_valid.reset_index(drop=True)
-    tabla_datos = tabla_datos.round(4)  # Redondear a 4 decimales si es necesario
+    tabla_datos = tabla_datos.round(4)
     columnas = tabla_datos.columns.tolist()
     registros = tabla_datos.values.tolist()
 
-    # Crear tabla en Word
     tabla = doc.add_table(rows=1 + len(registros), cols=len(columnas))
     tabla.style = 'Table Grid'
 
-    # Añadir los encabezados
     hdr_cells = tabla.rows[0].cells
     for idx, col_name in enumerate(columnas):
         hdr_cells[idx].text = col_name
 
-    # Añadir los registros
     for i, registro in enumerate(registros):
         row_cells = tabla.rows[i + 1].cells
         for j, valor in enumerate(registro):
             row_cells[j].text = str(valor)
 
-    # Formatear fuente de la tabla
     for row in tabla.rows:
         for cell in row.cells:
             for paragraph in cell.paragraphs:
                 paragraph.style = doc.styles['Normal']
 
-    # Guardar documento
     filename = 'informe_calibracion.docx'
     doc.save(filename)
     return filename
 
 def exportar_informe_latex(df_valid, informe_md):
-    # Generar código LaTeX
     informe_tex = r"""\documentclass{article}
 \usepackage[spanish]{babel}
 \usepackage{amsmath}
@@ -464,156 +389,142 @@ def exportar_informe_latex(df_valid, informe_md):
 def exportar_word(df, informe_md, unidad_medida, filas_seleccionadas):
     df_valid = df.copy()
     col_predicha_num = "Concentración Predicha Numérica"
-    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
+    col_real_promedio = [c for c in df_valid.columns if 'Real Promedio' in c][0] if any('Real Promedio' in c for c in df_valid.columns) else None
 
-    # Convertir columnas a numérico
-    df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
-    df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
-
-    df_valid = df_valid.dropna(subset=[col_predicha_num, col_real_promedio])
-
-    # Resetear el índice
+    if col_predicha_num in df_valid.columns:
+        df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
+    if col_real_promedio:
+        df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
+    df_valid = df_valid.dropna(subset=[col_predicha_num] if col_predicha_num else df_valid.columns[0], how='all')
     df_valid.reset_index(drop=True, inplace=True)
 
-    # Convertir filas_seleccionadas a índices
     if not filas_seleccionadas:
         return None
 
-    indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas]
-
-    # Filtrar filas según las seleccionadas
-    df_valid = df_valid.loc[indices_seleccionados]
+    indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas if s.split(' ')[1].isdigit() and int(s.split(' ')[1]) - 1 < len(df_valid)]
+    if indices_seleccionados:
+        df_valid = df_valid.loc[indices_seleccionados]
+    else:
+        df_valid = df_valid.iloc[:0]
 
     if df_valid.empty:
         return None
 
     filename = exportar_informe_word(df_valid, informe_md, unidad_medida)
-
-    return filename  # Retornamos el nombre del archivo
+    return filename
 
 def exportar_latex(df, informe_md, filas_seleccionadas):
     df_valid = df.copy()
     col_predicha_num = "Concentración Predicha Numérica"
-    col_real_promedio = [col for col in df_valid.columns if 'Real Promedio' in col][0]
+    col_real_promedio = [col for col in df_valid.columns if 'Real Promedio' in col][0] if any('Real Promedio' in c for c in df_valid.columns) else None
 
-    # Convertir columnas a numérico
-    df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
-    df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
+    if col_predicha_num in df_valid.columns:
+        df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
+    if col_real_promedio:
+        df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
 
-    df_valid = df_valid.dropna(subset=[col_predicha_num, col_real_promedio])
-
-    # Resetear el índice
+    df_valid = df_valid.dropna(subset=[col_predicha_num] if col_predicha_num else df_valid.columns[0], how='all')
     df_valid.reset_index(drop=True, inplace=True)
 
-    # Convertir filas_seleccionadas a índices
     if not filas_seleccionadas:
         return None
 
-    indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas]
-
-    # Filtrar filas según las seleccionadas
-    df_valid = df_valid.loc[indices_seleccionados]
+    indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas if s.split(' ')[1].isdigit() and int(s.split(' ')[1]) - 1 < len(df_valid)]
+    if indices_seleccionados:
+        df_valid = df_valid.loc[indices_seleccionados]
+    else:
+        df_valid = df_valid.iloc[:0]
 
     if df_valid.empty:
         return None
 
     filename = exportar_informe_latex(df_valid, informe_md)
-
-    return filename  # Retornamos el nombre del archivo
-
-def cargar_ejemplo_ufc(n_replicas):
-    df = generar_tabla(7, 2000000, "UFC", n_replicas)
-    # Valores reales de ejemplo
-    for i in range(1, n_replicas + 1):
-        valores_reales = [2000000 - (i - 1) * 10000, 1600000 - (i - 1) * 8000, 1200000 - (i - 1) * 6000,
-                          800000 - (i - 1) * 4000, 400000 - (i - 1) * 2000, 200000 - (i - 1) * 1000,
-                          100000 - (i - 1) * 500]
-        df[f"Concentración Real {i} (UFC)"] = valores_reales
-    return 2000000, "UFC", 7, df
-
-def cargar_ejemplo_od(n_replicas):
-    df = generar_tabla(7, 1.000, "OD", n_replicas)
-    # Valores reales de ejemplo
-    for i in range(1, n_replicas + 1):
-        valores_reales = [1.000 - (i - 1) * 0.050, 0.800 - (i - 1) * 0.040, 0.600 - (i - 1) * 0.030,
-                          0.400 - (i - 1) * 0.020, 0.200 - (i - 1) * 0.010, 0.100 - (i - 1) * 0.005,
-                          0.050 - (i - 1) * 0.002]
-        df[f"Concentración Real {i} (OD)"] = valores_reales
-    return 1.000, "OD", 7, df
+    return filename
 
 def limpiar_datos(n_replicas):
-    df = generar_tabla(7, 2000000, "UFC", n_replicas)
+    df = pd.DataFrame({
+        "Solución": [1/(2**i) for i in range(7)],
+        "H2O": [1-(1/(2**i)) for i in range(7)],
+        "Factor de Dilución": [(1/(1/(2**i))) for i in range(7)],
+        "Concentración Predicha Numérica": [2000000/(1/(1/(2**i))) for i in range(7)],
+        "Concentración Predicha (mg/L)": [2000000/(1/(1/(2**i))) for i in range(7)]
+    })
     return (
-        2000000,   # Concentración Inicial
-        "UFC",     # Unidad de Medida
-        7,         # Número de filas
-        df,        # Tabla Output
-        "",        # Estado Output
-        None,      # Gráficos Output
-        ""         # Informe Output
+        2000000,  
+        "UFC",    
+        7,        
+        df,       
+        "",       
+        None,     
+        ""        
     )
 
 def generar_datos_sinteticos_evento(df, n_replicas, unidad_medida):
     df = df.copy()
     col_predicha_num = "Concentración Predicha Numérica"
-
-    # Generar datos sintéticos para cada réplica
-    for i in range(1, n_replicas + 1):
-        col_real = f"Concentración Real {i} ({unidad_medida})"
+    if col_predicha_num in df.columns:
         df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
-        desviacion_std = 0.05 * df[col_predicha_num].mean()  # 5% de la media como desviación estándar
-        valores_predichos = df[col_predicha_num].astype(float).values
-        datos_sinteticos = valores_predichos + np.random.normal(0, desviacion_std, size=len(valores_predichos))
-        datos_sinteticos = np.maximum(0, datos_sinteticos)  # Asegurar que no haya valores negativos
-        datos_sinteticos = np.round(datos_sinteticos, 3)
-        df[col_real] = datos_sinteticos
+        for i in range(1, n_replicas + 1):
+            col_real = f"Concentración Real {i} ({unidad_medida})"
+            desviacion_std = 0.05 * df[col_predicha_num].mean()
+            valores_predichos = df[col_predicha_num].dropna().values
+            if len(valores_predichos) == 0:
+                continue
+            datos_sinteticos = valores_predichos + np.random.normal(0, desviacion_std, size=len(valores_predichos))
+            datos_sinteticos = np.maximum(0, datos_sinteticos)
+            datos_sinteticos = np.round(datos_sinteticos, 3)
+            df.loc[df[col_predicha_num].notna(), col_real] = datos_sinteticos
+    return df
 
+def actualizar_tabla_evento(df, n_filas, conc, unidad, n_replicas, decimales):
+    df = df.copy()
+    if len(df) > n_filas:
+        df = df.iloc[:n_filas].reset_index(drop=True)
+    else:
+        for i in range(len(df), n_filas):
+            df.loc[i, df.columns] = np.nan
+    df = ajustar_decimales_evento(df, decimales)
     return df
 
-def actualizar_tabla_evento(df, n_filas, concentracion, unidad, n_replicas, decimales):
-    # Actualizar tabla sin borrar "Concentración Real"
-    df_new = generar_tabla(n_filas, concentracion, unidad, n_replicas)
+def cargar_excel(file):
+    all_sheets = pd.read_excel(file.name, sheet_name=None)
 
-    # Mapear columnas
-    col_real_new = [col for col in df_new.columns if 'Concentración Real' in col and 'Promedio' not in col and 'Desviación' not in col]
-    col_real_old = [col for col in df.columns if 'Concentración Real' in col and 'Promedio' not in col and 'Desviación' not in col]
+    if len(all_sheets) < 3:
+        return "El archivo debe tener al menos tres pestañas (Hoja1, Hoja2, Hoja3).", None, None, None, None, None, None, ""
 
-    # Reemplazar valores existentes en "Concentración Real"
-    for col_new, col_old in zip(col_real_new, col_real_old):
-        df_new[col_new] = None
-        for idx in df_new.index:
-            if idx in df.index:
-                df_new.at[idx, col_new] = df.at[idx, col_old]
+    sheet_names = list(all_sheets.keys())
+    sheet1_name = sheet_names[0]
+    sheet2_name = sheet_names[1]
+    sheet3_name = sheet_names[2]
 
-    # Ajustar decimales
-    df_new = ajustar_decimales_evento(df_new, decimales)
+    df_sheet1 = all_sheets[sheet1_name]
+    df_sheet2 = all_sheets[sheet2_name]
+    df_sheet3 = all_sheets[sheet3_name]
 
-    return df_new
+    df_base = df_sheet1.iloc[:, :5].copy()
 
-def cargar_excel(file):
-    # Leer el archivo Excel
-    df = pd.read_excel(file.name, sheet_name=None)
+    primera_col = df_base.columns[0]
+    try:
+        parte_interna = primera_col.split('(')[1].split(')')[0]
+        partes = parte_interna.split()
+        unidad_medida = partes[-1]
+        concentracion_inicial = float("".join(partes[:-1]))
+    except:
+        concentracion_inicial = 2000000.0
+        unidad_medida = "UFC"
 
-    # Verificar que el archivo tenga al menos dos pestañas
-    if len(df) < 2:
-        return "El archivo debe tener al menos dos pestañas.", None, None, None, None, None, None
+    n_filas = len(df_base)
+    n_replicas = 2
 
-    # Obtener la primera pestaña como referencia
-    primera_pestaña = next(iter(df.values()))
-    concentracion_inicial = primera_pestaña.iloc[0, 0]
-    unidad_medida = primera_pestaña.columns[0].split('(')[-1].split(')')[0]
-    n_filas = len(primera_pestaña)
-    n_replicas = len(df)
+    df_sistema = df_base.copy()
 
-    # Generar la tabla base
-    df_base = generar_tabla(n_filas, concentracion_inicial, unidad_medida, n_replicas)
+    col_replica_1 = df_sheet2.iloc[:n_filas, 1].values if df_sheet2.shape[1] > 1 else df_sheet2.iloc[:n_filas,0].values
+    col_replica_2 = df_sheet3.iloc[:n_filas, 1].values if df_sheet3.shape[1] > 1 else df_sheet3.iloc[:n_filas,0].values
 
-    # Llenar la tabla con los datos de cada pestaña
-    for i, (sheet_name, sheet_df) in enumerate(df.items(), start=1):
-        col_real = f"Concentración Real {i} ({unidad_medida})"
-        df_base[col_real] = sheet_df.iloc[:, 1].values
+    df_sistema[f"Concentración Real 1 ({unidad_medida})"] = col_replica_1
+    df_sistema[f"Concentración Real 2 ({unidad_medida})"] = col_replica_2
 
-    return concentracion_inicial, unidad_medida, n_filas, n_replicas, df_base, "", None, ""
+    return concentracion_inicial, unidad_medida, n_filas, n_replicas, df_sistema, "", None, ""
 
 def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_regresion,
                                        palette_puntos, estilo_puntos,
@@ -627,48 +538,41 @@ def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_re
         return "Datos insuficientes", None, None, None
 
     col_concentracion = "Concentración Predicha Numérica"
-    col_absorbancia = f"Concentración Real Promedio ({unidad_medida})"
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
     col_desviacion = f"Desviación Estándar ({unidad_medida})"
 
-    # Calcular promedio y desviación estándar si es necesario
-    n_replicas = len([col for col in df.columns if 'Concentración Real' in col and 'Promedio' not in col and 'Desviación' not in col])
+    n_replicas = len([c for c in df.columns if 'Concentración Real' in c and 'Promedio' not in c and 'Desviación' not in c])
     df = calcular_promedio_desviacion(df, n_replicas, unidad_medida, decimales)
 
-    # Convertir columnas a numérico
-    df[col_concentracion] = pd.to_numeric(df[col_concentracion], errors='coerce')
-    df[col_absorbancia] = pd.to_numeric(df[col_absorbancia], errors='coerce')
-    df[col_desviacion] = pd.to_numeric(df[col_desviacion], errors='coerce')
+    if col_concentracion not in df.columns or col_real_promedio not in df.columns:
+        return "Faltan columnas necesarias", None, None, None
 
-    df_valid = df.dropna(subset=[col_concentracion, col_absorbancia])
+    df[col_concentracion] = pd.to_numeric(df[col_concentracion], errors='coerce')
+    df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
+    df[col_desviacion] = pd.to_numeric(df[col_desviacion], errors='coerce').fillna(0)
 
-    # Resetear el índice para asegurar que sea secuencial
+    df_valid = df.dropna(subset=[col_concentracion, col_real_promedio])
     df_valid.reset_index(drop=True, inplace=True)
 
-    # Asegurar que el gráfico original tenga todos los puntos
     df_original = df_valid.copy()
 
-    # Convertir filas_seleccionadas a índices
     if not filas_seleccionadas_regresion:
         return "Se necesitan más datos", None, None, None
 
-    indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas_regresion]
+    indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas_regresion if s.split(' ')[1].isdigit() and int(s.split(' ')[1]) - 1 < len(df_valid)]
+    if len(indices_seleccionados) < 2:
+        return "Se requieren al menos dos puntos para calcular la regresión", None, None, None
 
-    # Filtrar filas según las seleccionadas para el gráfico personalizado
     df_valid = df_valid.loc[indices_seleccionados]
 
-    if len(df_valid) < 2:
-        return "Se requieren al menos dos puntos para calcular la regresión", None, None, None
-
-    # Calcular regresión lineal para el gráfico personalizado
-    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_concentracion], df_valid[col_absorbancia])
+    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_concentracion], df_valid[col_real_promedio])
 
-    # Generar gráfico original (con todos los puntos)
     sns.set(style="whitegrid")
     fig_original, ax_original = plt.subplots(figsize=(8, 6))
 
     ax_original.errorbar(
         df_original[col_concentracion],
-        df_original[col_absorbancia],
+        df_original[col_real_promedio],
         yerr=df_original[col_desviacion],
         fmt='o',
         color='blue',
@@ -678,8 +582,7 @@ def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_re
         label='Datos'
     )
 
-    # Calcular regresión para todos los puntos
-    slope_all, intercept_all, r_value_all, p_value_all, std_err_all = stats.linregress(df_original[col_concentracion], df_original[col_absorbancia])
+    slope_all, intercept_all, r_value_all, p_value_all, std_err_all = stats.linregress(df_original[col_concentracion], df_original[col_real_promedio])
 
     ax_original.plot(
         df_original[col_concentracion],
@@ -689,15 +592,11 @@ def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_re
         label='Ajuste Lineal'
     )
 
-    # Título y etiquetas personalizadas para el gráfico original
     ax_original.set_xlabel(eje_x_original if eje_x_original else 'Concentración Predicha Numérica')
     ax_original.set_ylabel(eje_y_original if eje_y_original else f'Concentración Real Promedio ({unidad_medida})')
     ax_original.set_title(titulo_grafico_original if titulo_grafico_original else 'Regresión Lineal: Concentración Real vs Concentración Predicha (Original)')
-
-    # Posicionar la leyenda según la opción seleccionada (por defecto 'lower right')
     ax_original.legend(loc=legend_location)
 
-    # Añadir ecuación y R² en el gráfico
     ax_original.annotate(
         f'y = {intercept_all:.4f} + {slope_all:.4f}x\n$R^2$ = {r_value_all**2:.4f}',
         xy=(0.05, 0.95),
@@ -707,11 +606,9 @@ def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_re
         verticalalignment='top'
     )
 
-    # Generar gráfico personalizado
     sns.set(style="whitegrid")
     fig_personalizado, ax_personalizado = plt.subplots(figsize=(8, 6))
 
-    # Obtener colores de las paletas
     colors_puntos = sns.color_palette(palette_puntos, as_cmap=False)
     colors_linea_ajuste = sns.color_palette(palette_linea_ajuste, as_cmap=False)
 
@@ -721,7 +618,7 @@ def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_re
     if mostrar_puntos:
         ax_personalizado.errorbar(
             df_valid[col_concentracion],
-            df_valid[col_absorbancia],
+            df_valid[col_real_promedio],
             yerr=df_valid[col_desviacion],
             fmt=estilo_puntos,
             color=color_puntos,
@@ -740,15 +637,11 @@ def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_re
             label='Ajuste Lineal'
         )
 
-    # Título y etiquetas personalizadas para el gráfico personalizado
     ax_personalizado.set_xlabel(eje_x_personalizado if eje_x_personalizado else 'Concentración Predicha Numérica')
     ax_personalizado.set_ylabel(eje_y_personalizado if eje_y_personalizado else f'Concentración Real Promedio ({unidad_medida})')
     ax_personalizado.set_title(titulo_grafico_personalizado if titulo_grafico_personalizado else 'Regresión Lineal Personalizada')
-
-    # Posicionar la leyenda según la opción seleccionada
     ax_personalizado.legend(loc=legend_location)
 
-    # Añadir ecuación y R² en el gráfico
     ax_personalizado.annotate(
         f'y = {intercept:.4f} + {slope:.4f}x\n$R^2$ = {r_value**2:.4f}',
         xy=(0.05, 0.95),
@@ -758,13 +651,11 @@ def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_re
         verticalalignment='top'
     )
 
-    # Crear tabla resumida
-    df_resumen = df_valid[[col_concentracion, col_absorbancia, col_desviacion]].copy()
+    df_resumen = df_valid[[col_concentracion, col_real_promedio, col_desviacion]].copy()
     df_resumen.columns = ['Concentración Predicha', 'Absorbancia Promedio', 'Desviación Estándar']
 
     return "Regresión calculada exitosamente", fig_original, fig_personalizado, df_resumen
 
-# Función corregida para actualizar las opciones de filas
 def actualizar_opciones_filas(df):
     if df is None or df.empty:
         update = gr.update(choices=[], value=[])
@@ -773,11 +664,10 @@ def actualizar_opciones_filas(df):
         update = gr.update(choices=opciones, value=opciones)
     return update, update
 
-# Interfaz Gradio
 with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     gr.Markdown("""
     # 📊 Sistema Avanzado de Calibración con Análisis Estadístico
-    Configure los parámetros, edite los valores en la tabla y luego presione "Calcular" para obtener el análisis.
+    Cargue el Excel con las 3 hojas (Hoja1 con 5 primeras columnas, Hoja2 y Hoja3 réplicas), edite y calcule.
     """)
 
     with gr.Tab("📝 Datos de Calibración"):
@@ -836,16 +726,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         estado_output = gr.Textbox(label="Estado", interactive=False)
         graficos_output = gr.Plot(label="Gráficos de Análisis")
 
-        # Reemplazar Multiselect por CheckboxGroup
         filas_seleccionadas = gr.CheckboxGroup(
             label="Seleccione las filas a incluir en el análisis",
             choices=[],
             value=[],
         )
 
-        # Opciones y botones debajo del gráfico
         with gr.Row():
-            # Paletas de colores disponibles en Seaborn
             paletas_colores = ["deep", "muted", "pastel", "bright", "dark", "colorblind", "Set1", "Set2", "Set3"]
 
             palette_puntos_dropdown = gr.Dropdown(
@@ -886,10 +773,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
                 label="Paleta Barras de Error"
             )
             mostrar_linea_ajuste = gr.Checkbox(value=True, label="Mostrar Línea de Ajuste")
-            mostrar_linea_ideal = gr.Checkbox(value=False, label="Mostrar Línea Ideal")  # Desmarcado por defecto
+            mostrar_linea_ideal = gr.Checkbox(value=False, label="Mostrar Línea Ideal")
             mostrar_puntos = gr.Checkbox(value=True, label="Mostrar Puntos")
             graficar_btn = gr.Button("📊 Graficar", variant="primary")
 
+        # Botón para recalcular informe
+        recalcular_btn = gr.Button("🔄 Calcular Otra Vez", variant="secondary")
+
         with gr.Row():
             copiar_btn = gr.Button("📋 Copiar Informe", variant="secondary")
             exportar_word_btn = gr.Button("💾 Exportar Informe Word", variant="primary")
@@ -899,20 +789,17 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             exportar_word_file = gr.File(label="Informe en Word")
             exportar_latex_file = gr.File(label="Informe en LaTeX")
 
-        # Informe al final
         informe_output = gr.Markdown(elem_id="informe_output")
 
     with gr.Tab("📈 Regresión Absorbancia vs Concentración"):
         gr.Markdown("## Ajuste de Regresión utilizando datos de la Tabla Principal")
 
-        # Casillas para seleccionar filas
         filas_seleccionadas_regresion = gr.CheckboxGroup(
             label="Seleccione las filas a incluir en el análisis de regresión",
             choices=[],
             value=[],
         )
 
-        # Opciones de personalización
         with gr.Row():
             paletas_colores = ["deep", "muted", "pastel", "bright", "dark", "colorblind", "Set1", "Set2", "Set3"]
             palette_puntos_regresion = gr.Dropdown(
@@ -945,11 +832,10 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
                     'right', 'center left', 'center right', 'lower center',
                     'upper center', 'center'
                 ],
-                value='lower right',  # Por defecto 'lower right'
+                value='lower right',
                 label='Ubicación de la Leyenda'
             )
 
-        # Campos de texto para personalizar título y ejes
         with gr.Row():
             titulo_grafico_original = gr.Textbox(
                 label="Título del Gráfico Original",
@@ -967,7 +853,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             )
             eje_y_original = gr.Textbox(
                 label="Etiqueta del Eje Y (Gráfico Original)",
-                placeholder=f"Concentración Real Promedio ({unidad_input.value})"
+                placeholder="Concentración Real Promedio (UFC)"
             )
 
         with gr.Row():
@@ -977,32 +863,28 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             )
             eje_y_personalizado = gr.Textbox(
                 label="Etiqueta del Eje Y (Gráfico Personalizado)",
-                placeholder=f"Concentración Real Promedio ({unidad_input.value})"
+                placeholder="Concentración Real Promedio (UFC)"
             )
 
         calcular_regresion_btn = gr.Button("Calcular Regresión")
 
-        # Salidas
         estado_regresion_output = gr.Textbox(label="Estado de la Regresión", interactive=False)
         grafico_original_output = gr.Plot(label="Gráfico Original")
         grafico_personalizado_output = gr.Plot(label="Gráfico Personalizado")
         tabla_resumen_output = gr.DataFrame(label="Tabla Resumida")
 
-    # Eventos para actualizar las opciones de filas
     tabla_output.change(
         fn=actualizar_opciones_filas,
         inputs=[tabla_output],
         outputs=[filas_seleccionadas, filas_seleccionadas_regresion]
     )
 
-    # Evento al presionar el botón Calcular
     calcular_btn.click(
         fn=actualizar_analisis,
         inputs=[tabla_output, replicas_slider, unidad_input, filas_seleccionadas, decimales_slider],
         outputs=[estado_output, graficos_output, informe_output, tabla_output]
     )
 
-    # Evento para graficar con opciones seleccionadas
     graficar_btn.click(
         fn=actualizar_graficos,
         inputs=[
@@ -1017,37 +899,51 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         outputs=graficos_output
     )
 
-    # Asegurar que la línea ideal esté desmarcada por defecto
+    # Nuevo botón "Calcular Otra Vez" para recalcular informe y gráfico
+    recalcular_btn.click(
+        fn=actualizar_analisis,
+        inputs=[tabla_output, replicas_slider, unidad_input, filas_seleccionadas, decimales_slider],
+        outputs=[estado_output, graficos_output, informe_output, tabla_output]
+    )
+
     def resetear_linea_ideal():
         return gr.update(value=False)
 
-    # Desmarcar 'Mostrar Línea Ideal' en eventos de botones
-    calcular_btn.click(
-        fn=resetear_linea_ideal,
-        outputs=mostrar_linea_ideal
-    )
-    limpiar_btn.click(
-        fn=resetear_linea_ideal,
-        outputs=mostrar_linea_ideal
-    )
-    ajustar_decimales_btn.click(
-        fn=resetear_linea_ideal,
-        outputs=mostrar_linea_ideal
-    )
-    sinteticos_btn.click(
-        fn=resetear_linea_ideal,
-        outputs=mostrar_linea_ideal
-    )
+    calcular_btn.click(fn=resetear_linea_ideal, outputs=mostrar_linea_ideal)
+    limpiar_btn.click(fn=resetear_linea_ideal, outputs=mostrar_linea_ideal)
+    ajustar_decimales_btn.click(fn=resetear_linea_ideal, outputs=mostrar_linea_ideal)
+    sinteticos_btn.click(fn=resetear_linea_ideal, outputs=mostrar_linea_ideal)
 
-    # Eventos de los botones adicionales, como limpiar, cargar ejemplos, ajustar decimales, etc.
-    # Evento para limpiar datos
     limpiar_btn.click(
         fn=limpiar_datos,
         inputs=[replicas_slider],
         outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output]
     )
 
-    # Eventos de los botones de ejemplo
+    def cargar_ejemplo_ufc(n_replicas):
+        df = pd.DataFrame({
+            "Solución": [1.00,0.80,0.67,0.60,0.53,0.47,0.40],
+            "H2O": [0.00,0.20,0.33,0.40,0.47,0.53,0.60],
+            "Factor de Dilución": [1.00,1.25,1.50,1.67,1.87,2.14,2.50],
+            "Concentración Predicha Numérica": [150,120,100,90,80,70,60],
+            "Concentración Predicha (mg/L)": [150,120,100,90,80,70,60]
+        })
+        for i in range(1, n_replicas + 1):
+            df[f"Concentración Real {i} (UFC)"] = np.nan
+        return 2000000, "UFC", 7, df
+
+    def cargar_ejemplo_od(n_replicas):
+        df = pd.DataFrame({
+            "Solución": [1.00,0.80,0.60,0.40,0.20,0.10,0.05],
+            "H2O": [0.00,0.20,0.40,0.60,0.80,0.90,0.95],
+            "Factor de Dilución": [1.00,1.25,1.67,2.50,5.00,10.00,20.00],
+            "Concentración Predicha Numérica": [1.0,0.8,0.6,0.4,0.2,0.1,0.05],
+            "Concentración Predicha (mg/L)": [1.0,0.8,0.6,0.4,0.2,0.1,0.05]
+        })
+        for i in range(1, n_replicas + 1):
+            df[f"Concentración Real {i} (OD)"] = np.nan
+        return 1.000, "OD", 7, df
+
     ejemplo_ufc_btn.click(
         fn=cargar_ejemplo_ufc,
         inputs=[replicas_slider],
@@ -1060,28 +956,24 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         outputs=[concentracion_input, unidad_input, filas_slider, tabla_output]
     )
 
-    # Evento para generar datos sintéticos
     sinteticos_btn.click(
         fn=generar_datos_sinteticos_evento,
         inputs=[tabla_output, replicas_slider, unidad_input],
         outputs=tabla_output
     )
 
-    # Evento para cargar archivo Excel
     cargar_excel_btn.upload(
         fn=cargar_excel,
         inputs=[cargar_excel_btn],
         outputs=[concentracion_input, unidad_input, filas_slider, replicas_slider, tabla_output, estado_output, graficos_output, informe_output]
     )
 
-    # Evento al presionar el botón Ajustar Decimales
     ajustar_decimales_btn.click(
         fn=ajustar_decimales_evento,
         inputs=[tabla_output, decimales_slider],
         outputs=tabla_output
     )
 
-    # Actualizar tabla al cambiar los parámetros (sin borrar "Concentración Real")
     def actualizar_tabla_wrapper(df, filas, conc, unidad, replicas, decimales):
         return actualizar_tabla_evento(df, filas, conc, unidad, replicas, decimales)
 
@@ -1115,7 +1007,6 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         outputs=tabla_output
     )
 
-    # Evento de copiar informe utilizando JavaScript
     copiar_btn.click(
         None,
         [],
@@ -1134,7 +1025,6 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         """
     )
 
-    # Eventos de exportar informes
     exportar_word_btn.click(
         fn=exportar_word,
         inputs=[tabla_output, informe_output, unidad_input, filas_seleccionadas],
@@ -1147,16 +1037,17 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         outputs=exportar_latex_file
     )
 
-    # Inicializar la interfaz con el ejemplo base
     def iniciar_con_ejemplo():
+        df = pd.DataFrame({
+            "Solución": [1.00,0.80,0.67,0.60,0.53,0.47,0.40],
+            "H2O": [0.00,0.20,0.33,0.40,0.47,0.53,0.60],
+            "Factor de Dilución": [1.00,1.25,1.50,1.67,1.87,2.14,2.50],
+            "Concentración Predicha Numérica": [150,120,100,90,80,70,60],
+            "Concentración Predicha (mg/L)": [150,120,100,90,80,70,60]
+        })
+        df["Concentración Real 1 (UFC)"] = [1.715,1.089,0.941,0.552,0.703,0.801,0.516]
         n_replicas = 1
-        df = generar_tabla(7, 2000000, "UFC", n_replicas)
-        # Valores reales de ejemplo
-        df[f"Concentración Real 1 (UFC)"] = [2000000, 1600000, 1200000, 800000, 400000, 200000, 100000]
-        # Calcular promedio y desviación estándar
-        df = calcular_promedio_desviacion(df, n_replicas, "UFC", 3)
-        filas_seleccionadas_inicial = [f"Fila {i+1}" for i in df.index]
-        estado, fig, informe, df = actualizar_analisis(df, n_replicas, "UFC", filas_seleccionadas_inicial, 3)
+        estado, fig, informe, df = actualizar_analisis(df, n_replicas, "UFC", [f"Fila {i+1}" for i in df.index], 3)
         return (
             2000000,
             "UFC",
@@ -1165,8 +1056,8 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             estado,
             fig,
             informe,
-            filas_seleccionadas_inicial,
-            3  # Número de decimales
+            [f"Fila {i+1}" for i in df.index],
+            3
         )
 
     interfaz.load(
@@ -1174,7 +1065,6 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output, filas_seleccionadas, decimales_slider]
     )
 
-    # Evento al presionar el botón de calcular regresión
     calcular_regresion_btn.click(
         fn=calcular_regresion_tabla_principal,
         inputs=[
@@ -1190,6 +1080,5 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         outputs=[estado_regresion_output, grafico_original_output, grafico_personalizado_output, tabla_resumen_output]
     )
 
-# Lanzar la interfaz
 if __name__ == "__main__":
     interfaz.launch()