29. Secuencias de colisiones y actualización del estado

29.1 Una colisión cambia el problema siguiente

En una secuencia, el estado final de un choque es el estado inicial del siguiente. Si A golpea a B y luego B alcanza a C, la velocidad usada en el segundo encuentro debe ser la que B adquirió en el primero.

29.2 Qué contiene el estado

Para cada cuerpo traslacional, el estado mínimo incluye masa, posición y velocidad:

La masa suele permanecer constante. Posiciones y velocidades cambian con el tiempo y deben almacenarse después de cada avance o colisión.

29.3 El ciclo fundamental

Cada iteración comienza con un estado coherente y termina con un nuevo estado coherente.

29.4 Resolver un par en una dimensión

Para dos cuerpos A y B con coeficiente de restitución e:

Solo se reemplazan las velocidades del par que colisiona. Los demás cuerpos conservan sus velocidades durante ese evento instantáneo.

29.5 Detectar aproximación entre vecinos

En una pista unidimensional, supongamos que A está a la izquierda de B. Si no se superponen, podrán colisionar cuando:

La velocidad relativa de cierre es v_A − v_B. Si es cero o negativa, la distancia no disminuye.

29.6 Tiempo hasta el contacto

Para centros separados por x_B − x_A y radios R_A, R_B, el espacio libre es:

Si d ≥ 0 y v_A > v_B:

29.7 Elegir el próximo evento

Se calcula el tiempo de contacto de cada par candidato y se elige el menor valor no negativo:

Para cuerpos ordenados que no pueden atravesarse, basta considerar pares vecinos. En dos dimensiones hacen falta técnicas de detección espacial más generales.

29.8 Avanzar todos los cuerpos

Antes de resolver el evento se actualizan todas las posiciones hasta el mismo instante:

Avanzar solamente el par produciría cuerpos descritos en instantes diferentes.

29.9 Actualización inmediata

En el instante del contacto se calculan las nuevas velocidades del par y se escriben en el estado antes de buscar otro evento.

Conviene calcular ambos resultados en variables temporales para que el segundo no use accidentalmente el primero ya actualizado.

29.10 Ejemplo: transferencia entre tres masas iguales

Tres cuerpos iguales están alineados. A avanza a +6 m/s y B y C están en reposo. Los choques son elásticos.

1. A alcanza a B. Para masas iguales, intercambian velocidades: A queda en reposo y B sale a +6 m/s.
2. B alcanza a C. Vuelven a intercambiar velocidades: B queda en reposo y C sale a +6 m/s.

El momento y la energía cinética se conservan en cada evento y en la secuencia completa.

29.11 El orden puede cambiar el resultado

Con masas diferentes o e < 1, resolver AB antes que BC generalmente produce un estado distinto de resolver BC antes que AB. La cronología física decide cuál corresponde.

Si dos eventos poseen tiempos claramente diferentes, no deben agruparse como simultáneos por comodidad.

29.12 Auditoría de cada evento

Para el par que colisiona se comprueba:

Un error pequeño en un choque puede propagarse a muchos eventos posteriores.

29.13 Auditoría de la secuencia completa

Sin impulsos externos, el momento global inicial debe coincidir con el momento actual:

Para 0 ≤ e ≤ 1, la energía cinética no puede aumentar en ningún choque pasivo. Si todos son elásticos, K debe permanecer constante dentro de la tolerancia.

29.14 Simulación con paso de tiempo fijo

Otro enfoque avanza un intervalo pequeño Δt, detecta superposiciones y las resuelve. Es sencillo y admite fuerzas continuas, pero introduce dificultades:

• un cuerpo rápido puede atravesar a otro entre cuadros;
• una superposición profunda vuelve ambigua la posición de contacto;
• el mismo contacto puede resolverse repetidamente;
• el resultado depende del tamaño de Δt y del orden de los pares.

29.15 Simulación dirigida por eventos

El método dirigido por eventos calcula el próximo instante exacto de contacto bajo movimiento uniforme. Es muy preciso para cuerpos rígidos sin fuerzas entre choques.

29.16 Contactos simultáneos

Si A, B y C están en contacto al mismo tiempo, no siempre existe un orden físico único de choques binarios. Resolver primero AB o BC puede introducir una preferencia artificial.

29.17 Tolerancias y contactos repetidos

Los errores de punto flotante pueden producir tiempos diminutos negativos, cuerpos apenas superpuestos o una cadena infinita de eventos con Δt ≈ 0.

• compará distancias y velocidades con tolerancias;
• descartá contactos cuyos cuerpos ya se separan;
• corregí penetraciones pequeñas sin agregar energía;
• establecé un máximo de eventos por actualización.

29.18 Procedimiento de implementación

29.19 Actividad interactiva: tres cuerpos en secuencia

Configurá masas, velocidades y restitución. Usá “Próxima colisión” para seguir la cronología evento por evento o reproducí la secuencia automáticamente.

29.20 Implementar el procesador de eventos

Este ejemplo compacto busca el próximo choque entre cuerpos vecinos:

function tiempoDeChoque(a, b, tolerancia = 1e-10) {
  const espacio = b.x - a.x - a.radio - b.radio;
  const cierre = a.v - b.v;
  if (cierre <= tolerancia) return Infinity;
  return Math.max(0, espacio) / cierre;
}

function resolverPar(a, b, e) {
  const uA = a.v;
  const uB = b.v;
  const masaTotal = a.masa + b.masa;
  a.v = ((a.masa - e * b.masa) * uA
    + (1 + e) * b.masa * uB) / masaTotal;
  b.v = ((b.masa - e * a.masa) * uB
    + (1 + e) * a.masa * uA) / masaTotal;
}

function proximoEvento(cuerpos) {
  let mejor = { dt: Infinity, indice: -1 };
  for (let i = 0; i < cuerpos.length - 1; i++) {
    const dt = tiempoDeChoque(cuerpos[i], cuerpos[i + 1]);
    if (dt < mejor.dt) mejor = { dt, indice: i };
  }
  return mejor;
}

function procesarSiguiente(cuerpos, e) {
  const evento = proximoEvento(cuerpos);
  if (!Number.isFinite(evento.dt)) return null;
  cuerpos.forEach(cuerpo => cuerpo.x += cuerpo.v * evento.dt);
  resolverPar(cuerpos[evento.indice], cuerpos[evento.indice + 1], e);
  return evento;
}

const cuerpos = [
  { id: "A", x: 2, radio: 0.5, masa: 1, v: 4 },
  { id: "B", x: 8, radio: 0.5, masa: 2, v: 1 },
  { id: "C", x: 12, radio: 0.5, masa: 1, v: 0 }
];

console.log("Estado inicial:", JSON.stringify(cuerpos));
const evento = procesarSiguiente(cuerpos, 0.8);
console.log("Próximo evento:", evento);
console.log("Estado posterior:", JSON.stringify(cuerpos, null, 2));

29.21 Errores frecuentes y ejercicios

Errores frecuentes

• Resolver cada choque con las velocidades iniciales de toda la secuencia.
• Actualizar una velocidad del par antes de calcular la otra.
• Avanzar solo los cuerpos que colisionan.
• Procesar un contacto aunque la velocidad relativa indique separación.
• Elegir un par por cercanía en vez de comparar tiempos de contacto.
• Tratar contactos simultáneos como independientes sin documentar el orden.
• No limitar eventos casi instantáneos causados por errores numéricos.

Ejercicios propuestos

1. Dos cuerpos están en x_A = 2 m y x_B = 8 m, tienen radios de 0,5 m y velocidades +4 y +1 m/s. Calculá el tiempo de choque.
2. Agregá C en x = 12 m con v = 0 y radio 0,5 m. Compará Δt_AB y Δt_BC.
3. Para tres masas iguales con velocidades (+5, 0, 0), describí dos choques elásticos sucesivos.
4. Repetí el ejercicio anterior con e = 0 y explicá por qué cambia la secuencia.
5. Explicá por qué ambas velocidades de un par deben calcularse antes de escribirlas.
6. Indicá dos problemas que puede causar un Δt fijo demasiado grande.
7. Usá el laboratorio con m_A = 1, m_B = 2, m_C = 1 y e = 0,8. Registrá el orden de eventos.

29.22 Ideas para recordar

• El estado final de cada choque alimenta el evento siguiente.
• La cronología se obtiene comparando tiempos de contacto, no solo distancias.
• Todos los cuerpos deben avanzar hasta el mismo instante del evento.
• Las dos velocidades de un par se calculan desde el mismo estado anterior.
• Cada evento y la secuencia completa deben satisfacer los balances físicos.
• El paso fijo y la simulación por eventos poseen ventajas y limitaciones diferentes.
• Los contactos simultáneos no siempre pueden reducirse a un orden de pares.
• Las tolerancias evitan eventos falsos y bucles numéricos.

En el próximo tema diseñaremos estructuras para representar cuerpos, impulsos y colisiones con JavaScript.