Problema 1: Modelo de Ensamblaje (Soldadura)

1.1. Modelado y Parámetros del Sistema

Se modela un proceso de ensamblaje (soldadura) donde la salida final, Longitud Total (\(L\)), es el resultado de la suma de dos procesos de entrada (\(x_1\) y \(x_2\)).

  • Entrada 1 (\(x_1\)): \(N(\mu=30, \sigma^2=0.81) \implies \sigma = 0.9\)
  • Entrada 2 (\(x_2\)): \(N(\mu=18, \sigma=0.3)\)
  • Proceso: \(L = x_1 + x_2\)
  • Restricciones (Especificaciones):
    • Límite Inferior (LSL): 45 cm
    • Límite Superior (USL): 55 cm
  • Objetivo: Validar la capacidad del proceso (\(C_p, C_{pk}\)) y estimar la tasa de defectos (OOS) mediante una simulación de Montecarlo de 500 ejecuciones.

1.2. Ejecución de Simulación y Trazabilidad

Se generan 500 instancias del proceso. Los datos se capturan en un data.frame para su posterior análisis y trazabilidad.

set.seed(42) # Para reproducibilidad
n_sim <- 500

# Parámetros del modelo
media_x1 <- 30
sd_x1 <- sqrt(0.81) 
media_x2 <- 18
sd_x2 <- 0.3
LSL <- 45
USL <- 55

# Simulación 
x1 <- rnorm(n_sim, mean = media_x1, sd = sd_x1)
x2 <- rnorm(n_sim, mean = media_x2, sd = sd_x2)
L_ensamblado <- x1 + x2 # Salida del proceso

# 1. Almacenar datos en un data.frame para trazabilidad
df_barras <- data.frame(
  Ejecucion_ID = 1:n_sim,
  Entrada_x1 = round(x1, 4),
  Entrada_x2 = round(x2, 4),
  Salida_L_Total = round(L_ensamblado, 4)
)

# 2. Mostrar log de simulación
cat("Trazabilidad: Primeras 6 filas (de 500) generadas:\n")
## Trazabilidad: Primeras 6 filas (de 500) generadas:
kable(head(df_barras), caption = "Log de Primeras 6 Simulaciones (Problema 1)")
Log de Primeras 6 Simulaciones (Problema 1)
Ejecucion_ID Entrada_x1 Entrada_x2 Salida_L_Total
1 31.2339 18.3087 49.5426
2 29.4918 18.2744 47.7662
3 30.3268 17.9993 48.3261
4 30.5696 18.0408 48.6104
5 30.3638 17.7840 48.1478
6 29.9045 17.9406 47.8451 
# 3. Exportar CSV
write.csv(df_barras, "log_simulacion_p1.csv", row.names = FALSE)

1.3. Análisis de Capacidad de Proceso

Se analizan los 500 puntos de datos de salida (\(L\)) para calcular las métricas de rendimiento.

L <- L_ensamblado # Usar el vector de salida

# 1. Tasa de Fallos (OOS)
fuera_spec <- sum(L < LSL | L > USL)
prob_fuera_spec <- fuera_spec / n_sim

cat(paste("Total de ejecuciones:", n_sim, "\n"))
## Total de ejecuciones: 500
cat(paste("Fallos (OOS) detectados:", fuera_spec, "\n"))
## Fallos (OOS) detectados: 0
cat(paste("Tasa de fallo estimada:", round(prob_fuera_spec * 100, 2), "%\n\n"))
## Tasa de fallo estimada: 0 %
# 2. Índices de Capacidad (Cp y Cpk)
mu_proceso <- mean(L)
sigma_proceso <- sd(L)

Cp <- (USL - LSL) / (6 * sigma_proceso)
Cpk_sup <- (USL - mu_proceso) / (3 * sigma_proceso)
Cpk_inf <- (mu_proceso - LSL) / (3 * sigma_proceso)
Cpk <- min(Cpk_sup, Cpk_inf)

# Imprimir métricas
cat(paste("Media del proceso (μ):", round(mu_proceso, 4), "\n"))
## Media del proceso (μ): 47.9665
cat(paste("Desv. Estándar del proceso (σ):", round(sigma_proceso, 4), "\n\n"))
## Desv. Estándar del proceso (σ): 0.9258
cat(paste("Capacidad Potencial (Cp):", round(Cp, 4), "\n"))
## Capacidad Potencial (Cp): 1.8003
cat(paste("Capacidad Real (Cpk):", round(Cpk, 4), "\n"))
## Capacidad Real (Cpk): 1.0681

1.4. Análisis Gráfico de Resultados

Un histograma nos permite validar visualmente la distribución de la salida del proceso contra las restricciones (LSL/USL).

ggplot(data = df_barras, aes(x = Salida_L_Total)) +
  geom_histogram(binwidth = 0.2, fill = "lightblue", color = "black", alpha = 0.8) +
  geom_vline(xintercept = LSL, color = "red", linetype = "dashed", size = 1) +
  geom_vline(xintercept = USL, color = "red", linetype = "dashed", size = 1) +
  geom_vline(xintercept = mu_proceso, color = "blue", linetype = "dotted", size = 1.2) +
  labs(title = "Distribución de Salida del Proceso vs. Límites de Especificación",
       x = "Longitud Total (cm)",
       y = "Frecuencia (de 500 ejecuciones)",
       caption = paste("Límites (LSL/USL) en rojo. Media del Proceso (", round(mu_proceso, 2), "cm) en azul.")) +
  theme_minimal()

1.5. Diagnóstico del Proceso

El análisis de los 500 puntos de datos simulados arroja lo siguiente:

  1. Tasa de Fallos: La simulación no generó fallos (0%).
  2. Capacidad Potencial (\(C_p\)): El \(C_p \approx 1.8\) es alto (> 1.33). Esto indica que la variabilidad natural del proceso (su \(\sigma\), o “ruido”) es baja y el proceso potencialmente es capaz.
  3. Capacidad Real (\(C_{pk}\)): El \(C_{pk} \approx 1.07\) es el indicador crítico. Al ser < 1.33, revela un problema de centrado.

Respuesta: El histograma confirma el diagnóstico. La media del proceso (\(\mu \approx 48\)) está desviada hacia el límite inferior (45).

Diagnóstico: El proceso no es capaz (\(C_{pk} < 1.33\)) debido a un error sistemático (un bias) que lo descentra, no por un problema de variabilidad aleatoria (ruido).

Problema 2: Sistema de Colas (Estación de Reproceso)

2.1. Modelado del Sistema de Colas (D/G/1)

Se modela una estación de reproceso como un sistema de colas de servidor único (G/G/1). Específicamente, es un D/G/1 porque las llegadas son Determinísticas (D).

  • Entidad: Pieza.
  • Lote: 200 piezas.
  • Llegadas (D): Determinísticas. Intervalo entre llegadas = 20 min.
  • Servidor (1): Taller de reproceso.
  • Proceso de Servicio (G): El tiempo de servicio es variable y depende de un atributo de la entidad (número de defectos).
    • \(Defectos \sim \text{Binomial}(n=3, p=0.8)\). (\(\mu = 2.4\)).
    • \(T_{\text{reparacion_defecto}} \sim \text{Exponencial}(\lambda=0.2) \implies \mu_{\text{defecto}} = 5\) min.
    • \(T_{\text{servicio_total}} \sim \text{Exponencial}(\lambda_D = 1 / (Defectos \times 5))\).
  • Objetivo: Estimar el tiempo total de ciclo (Makespan) para el lote de 200 piezas, usando 10 réplicas.

2.2. Simulación por Eventos

Se implementa un bucle for por cada réplica. Dentro de cada réplica, otro bucle simula cada evento (llegada de pieza j) y actualiza el estado del sistema (reloj y estado del servidor).

set.seed(42)
n_replicas <- 10
n_piezas <- 200
tasa_llegada <- 20 # minutos entre piezas
lambda_defecto <- 0.2
media_t_defecto <- 1 / lambda_defecto # 5 minutos

# Se el resultado (tiempo de ciclo) de cada réplica
resultados_replicas_t2 <- numeric(n_replicas)

# Bucle de Réplicas (i) 
for (i in 1:n_replicas) {
  
  # Inicializar el estado del servidor (Taller) para esta réplica
  tiempo_salida_taller <- 0 # El taller está libre en el minuto 0
  
  # Bucle de Eventos (j)
  for (j in 1:n_piezas) {
    
    # 1. Evento: Llegada de la pieza 'j'
    tiempo_llegada <- j * tasa_llegada
    
    # 2. Simular atributos de la entidad (Defectos)
    defectos <- rbinom(1, size = 3, prob = 0.8)
    
    # 3. Simular tiempo de servicio (basado en atributos)
    tiempo_reparacion <- 0
    if (defectos > 0) {
      media_t_total <- defectos * media_t_defecto
      tasa_total <- 1 / media_t_total
      tiempo_reparacion <- rexp(1, rate = tasa_total)
    }
    
    # 4. Lógica de Cola: El servicio inicia en max(llegada_entidad, servidor_libre)
    tiempo_inicio_reparacion <- max(tiempo_llegada, tiempo_salida_taller)
    
    # 5. Calcular tiempo de finalización del evento
    tiempo_fin_reparacion <- tiempo_inicio_reparacion + tiempo_reparacion
    
    # 6. Actualizar estado del servidor para el próximo evento (j+1)
    tiempo_salida_taller <- tiempo_fin_reparacion
  }
  
  # Guardar el resultado final de la réplica 'i'
  resultados_replicas_t2[i] <- tiempo_salida_taller
}

2.3. Tiempos de Ciclo (Makespan) por Réplica

Se presenta el tiempo de finalización de la pieza 200 para cada una de las 10 ejecuciones del modelo.

# Crear la tabla de resultados
tabla_resultados_t2 <- data.frame(
  Replica = 1:n_replicas,
  Tiempo_Total_Minutos = resultados_replicas_t2
)

# Imprimir la tabla
kable(tabla_resultados_t2, 
      caption = "Tiempo Total (Makespan) para Procesar 200 Piezas (10 Réplicas)",
      digits = 2)
Tiempo Total (Makespan) para Procesar 200 Piezas (10 Réplicas)
Replica Tiempo_Total_Minutos
1 4018.83
2 4009.64
3 4015.58
4 4003.34
5 4012.00
6 4040.39
7 4000.80
8 4023.88
9 4012.42
10 4009.12 
# Calcular e imprimir el promedio
tiempo_promedio <- mean(resultados_replicas_t2)
cat(paste("\n\nTiempo promedio de las 10 réplicas:", round(tiempo_promedio, 2), "minutos.\n"))
## 
## 
## Tiempo promedio de las 10 réplicas: 4014.6 minutos.
ggplot(data.frame(Replica = 1:10, Tiempo = resultados_replicas_t2), 
       aes(x = Replica, y = Tiempo)) +
  geom_line(color = "darkorange", size = 1) +
  geom_point(size = 3, color = "firebrick") +
  geom_hline(yintercept = mean(resultados_replicas_t2), 
             linetype = "dashed", color = "red") +
  annotate("text", x = 9, y = mean(resultados_replicas_t2) + 10, 
           label = "Promedio", color = "red") +
  labs(title = "Variabilidad del Tiempo Total – Estación de Reproceso",
       x = "Réplicas de simulación",
       y = "Tiempo total (min)") +
  theme_minimal()

2.4. Estimación del Rendimiento

Basado en 10 réplicas del modelo, el tiempo promedio de ciclo (Makespan) para un lote de 200 piezas es de aproximadamente 4014.6 minutos.

2.5. Análisis y Recomendaciones

Análisis:
El modelo D/G/1 representa un sistema con llegadas determinísticas cada 20 minutos y tiempos de servicio variables según los defectos de cada pieza.
En promedio, el procesamiento del lote de 200 piezas tarda 4014.6 minutos (≈ 66.91 horas).
El sistema se mantiene estable, aunque la variabilidad en los defectos genera fluctuaciones en el tiempo total de procesamiento.

Recomendaciones:
- Mantener el ritmo de llegada actual para evitar congestión.
- Reducir la variabilidad del servicio mediante controles de calidad.
- Monitorear los tiempos ociosos del servidor para optimizar el flujo.

Conclusión:
El sistema es eficiente y estable, pero puede mejorar su predictibilidad reduciendo la variabilidad asociada a los defectos.

Problema 3: Simulación de Proceso Cíclico (Camión)

3.1. Modelado del Proceso Cíclico

Se modela un sistema de un solo camión que opera en ciclos durante 10 horas.

  • Entidad: 1 Camión.
  • Límite de Simulación: 10 horas (600 minutos).
  • Variables de estado (Tiempos de Proceso):
    • \(T_{\text{carga}}\): Uniforme(\(30 \pm 10\)) \(\implies \text{runif(1, 20, 40)}\)
    • \(T_{\text{viaje\_ida}}\): Exponencial(\(\mu=40\)) \(\implies \text{rexp(1, 1/40)}\)
    • \(T_{\text{descarga}}\): Uniforme(\(20 \pm 5\)) \(\implies \text{runif(1, 15, 25)}\)
    • \(T_{\text{viaje\_vuelta}}\): Exponencial(\(\mu=40\)) \(\implies \text{rexp(1, 1/40)}\)
  • Restricción (3c): 1 bahía de carga (irrelevante para 1 camión, pero crítico si se escala).
  • Métricas: (a) Viajes por réplica, (b) IC 95% de viajes, (c) Análisis para 10 entregas.

3.2. Ejecución de Réplicas (Basada en Tiempo)

Simulamos el ciclo del camión 5 veces. Un “viaje” se cuenta como completado (evento clave) después de la descarga.

set.seed(42)
n_replicas_camion <- 5
tiempo_simulacion <- 600 # Reloj de simulación: 10 horas * 60 minutos

# Vector para guardar el contador de viajes por réplica
viajes_por_replica <- numeric(n_replicas_camion)

# Data.frame para la trazabilidad de todos los ciclos
todos_los_ciclos <- data.frame()

# Bucle de las 5 réplicas
for (i in 1:n_replicas_camion) {
  
  # Inicializar reloj y contadores para la réplica 'i'
  tiempo_actual <- 0
  viajes_completados <- 0
  
  # Iniciar bucle de simulación (mientras T < 600)
  while (TRUE) {
    
    # Simular tiempos de proceso para el ciclo actual
    t_carga <- runif(1, min = 20, max = 40)
    t_viaje_ida <- rexp(1, rate = 1/40)
    t_descarga <- runif(1, min = 15, max = 25)
    
    tiempo_hasta_entrega <- t_carga + t_viaje_ida + t_descarga
    
    # Condición de parada: ¿Puede completar la entrega (evento clave) antes de T=600?
    if (tiempo_actual + tiempo_hasta_entrega > tiempo_simulacion) {
      break # Terminar la réplica
    }
    
    # Actualizar reloj y contador (evento 'viaje_completado')
    tiempo_actual <- tiempo_actual + tiempo_hasta_entrega
    viajes_completados <- viajes_completados + 1
    
    # Simular proceso de retorno
    t_viaje_vuelta <- rexp(1, rate = 1/40)
    
    # Guardar log del ciclo (trazabilidad)
    todos_los_ciclos <- rbind(todos_los_ciclos, data.frame(
      Replica = i,
      Viaje_N = viajes_completados,
      T_Carga = t_carga,
      T_Viaje_Ida = t_viaje_ida,
      T_Descarga = t_descarga,
      T_Viaje_Vuelta = t_viaje_vuelta,
      Tiempo_Acumulado = tiempo_actual + t_viaje_vuelta
    ))
    
    # Condición de parada: ¿Puede volver a la base antes de T=600 para iniciar otro ciclo?
    if (tiempo_actual + t_viaje_vuelta > tiempo_simulacion) {
      break # Terminar la réplica
    }
    
    # Si puede volver, actualizamos el tiempo y el ciclo reinicia
    tiempo_actual <- tiempo_actual + t_viaje_vuelta
  }
  
  # Guardar el total de viajes de esta réplica
  viajes_por_replica[i] <- viajes_completados
}
# Simulación del Proceso
resultados_replicas_t3 <- replicate(10, {
  tiempo_total <- 0
  for (i in 1:200) {
    tiempo_total <- tiempo_total + rlnorm(1, meanlog = 3, sdlog = 0.3)
  }
  tiempo_total
})

### Resultados Promedio
mean(resultados_replicas_t3)
## [1] 4178.803

3.3. Análisis de Resultados (partes a, b, c)

a) Resultados de las 5 Réplicas

tabla_resultados_t3 <- data.frame(
  Replica = 1:n_replicas_camion,
  Viajes_Completados = viajes_por_replica
)
kable(tabla_resultados_t3, caption = "Viajes Completados en 10 Horas (5 Réplicas)")
Viajes Completados en 10 Horas (5 Réplicas)
Replica Viajes_Completados
1 6
2 3
3 4
4 3
5 2

b) Intervalo de Confianza para el Número de Viajes

Se usa t.test() sobre los 5 resultados para estimar el rango de la media real.

ic_viajes <- t.test(viajes_por_replica, conf.level = 0.95)

# Imprimir el IC
cat(paste("\nMedia de viajes:", round(ic_viajes$estimate, 2), "\n"))
## 
## Media de viajes: 3.6
cat(paste("Intervalo de Confianza 95% para los viajes: [", 
          round(ic_viajes$conf.int[1], 4), 
          ",", 
          round(ic_viajes$conf.int[2], 4), 
          "]\n"))
## Intervalo de Confianza 95% para los viajes: [ 1.7169 , 5.4831 ]

c) Diagnóstico y Recomendaciones para 10 entregas

Análisis: El IC del 95% (1.72 - 5.48) y la media (3.6) validan que el sistema actual está lejos de cumplir el objetivo de 10 entregas.

El análisis de los parámetros promedio revela el cuello de botella:

  • Carga (Promedio): (20+40)/2 = 30 min
  • Viaje Ida (Promedio): 40 min
  • Descarga (Promedio): (15+25)/2 = 20 min
  • Viaje Vuelta (Promedio): 40 min
  • Total Ciclo Esperado: 30 + 40 + 20 + 40 = 130 minutos

En 600 minutos, el throughput máximo teórico es \(600/130 \approx 4.6\) viajes/día, lo que nuestra simulación confirma.

Recomendaciones:

  1. Paralelización (Añadir Camión): La solución sería paralelizar el proceso con un segundo camión. Sin embargo, esto creará un nuevo estado de “Espera” (cola) en la bahía de carga (que pasa de ser un recurso 100% disponible a ser un servidor G/G/1). Se requeriría un nuevo modelo de simulación para validar si la espera en la bahía anula la ganancia del segundo camión.
  2. Optimización del Proceso (Reducir Tiempos): El análisis del ciclo (T_viaje_total = 80 min) muestra que los viajes consumen el 61.5% del tiempo. Optimizar rutas (reducir T_viaje) tendría el mayor impacto. Optimizar T_carga (23%) sería el segundo objetivo.

Simulación (Problema 3)

Aquí se muestran los datos detallados de cada ciclo de viaje simulado en las 5 réplicas. Los tiempos están en minutos.

Log de Datos Detallados de Simulación (Problema 3)
Replica Viaje_N T_Carga T_Viaje_Ida T_Descarga T_Viaje_Vuelta Tiempo_Acumulado
1 1 38.30 7.93 21.42 1.53 69.17
1 2 34.73 58.55 21.57 16.41 200.43
1 3 29.15 17.53 24.35 28.59 300.05
1 4 29.25 3.26 19.75 4.83 357.13
1 5 38.08 59.84 24.89 2.29 482.23
1 6 27.80 12.39 22.38 24.88 569.68
2 1 36.66 199.84 21.12 48.46 306.07
2 2 28.72 118.82 24.74 52.34 530.68
2 3 32.80 9.24 18.98 22.78 614.48
3 1 20.78 19.90 21.77 70.26 132.71
3 2 25.22 1.15 21.76 15.71 196.55
3 3 23.79 31.13 23.28 15.46 290.21
3 4 24.81 125.93 16.40 60.93 518.28
4 1 30.29 273.86 20.82 65.98 390.95
4 2 27.18 11.65 22.76 5.09 457.63
4 3 24.67 100.77 15.86 36.56 635.49
5 1 33.35 338.49 22.34 41.02 435.20
5 2 30.30 19.52 21.19 10.10 516.31