Estado de $N$ -sistema corporal después del tiempo $t$ (bajo gravedad y colisión inelástica)

Question

Dados los centros de gravedad de $n$ cuerpos esféricos de masa unitaria, $p_1$ , $p_2$ , ... $p_n$ y suponiendo colisiones perfectamente inelásticas, ¿cómo se encuentra la ubicación de los cuerpos después del tiempo $t$ ?

Nota: Si $t$ es lo suficientemente largo, creo que todos los cuerpos se aglomerarán en un solo cuerpo de masa $n$ (pero no estoy seguro de si la ubicación de este cuerpo único será la misma que el centro de gravedad del estado inicial).

Sólo para aclarar, todo tiene velocidad cero en el momento $t = 0$ .

Answer 1

Es muy probable que no haya una forma analítica de mostrar dónde está el $n$ los cuerpos serán después del tiempo $t$ , dependiendo de lo grande que sea $n$ es. Lo mejor que puedes esperar es hacer una simulación numérica.

Esencialmente estás evolucionando dos ecuaciones (una para obtener la nueva posición y otra para obtener la nueva velocidad) para cada una de las partículas del sistema. Es decir, para cada cuerpo resuelves

$$\mathbf{x}(t+\mathrm{d}t)\simeq\mathbf{x}(t)+\mathbf{v}(t)\,\mathrm{d}t\\ \mathbf{v}(t+\mathrm{d}t)\simeq\mathbf{v}(t)+\mathbf{a}(t)\,\mathrm{d}t$$ donde $\mathbf{a}(t)=\mathbf{F}(t)/m$ con $\mathbf{F}(t)$ la fuerza gravitacional, $\mathbf{x}$ y $\mathbf{v}$ los vectores de posición y velocidad y $\mathrm{d}t$ un incremento en el tiempo. Las técnicas más avanzadas se denominan integración simpléctica técnicas, que generalmente se recomiendan para $n$ -porque conservan la energía, mientras que otros métodos habituales (p. ej, Esquema de Euler ) no lo hacen.

Suponiendo que se crea una clase Body que almacena la masa, la posición y la velocidad de cada partícula, su algoritmo de evolución temporal, utilizando un método simpléctico, sería algo así

// initializes bodies, t_end, dt, etc.
while (t <= t_end) {
    // Compute new accel.
    for (auto body : bodies) {
        accel[body] = calc_force(body, bodies) / body.mass;
    }
    // Compute new position
    for (auto body : bodies) {
        body.position += (body.velocity + 0.5 * accel[body] * dt) * dt;
    }
    // Compute new accel.
    for (auto body : bodies) {
        accel2[body] = calc_force(body, bodies) / body.mass;
    }
    // Compute new velocity
    for (auto body : bodies) {
        body.velocity += 0.5 * (accel[body] + accel2[body]) * dt;
    }
    t += dt;
}

(Tengo otros detalles aquí y aquí ; véase también buscar: verlet o buscar: integrador simpléctico para más)

La función calc_force puede optimizarse un poco ya que $F_{i,j}=-F_{j,i}$ pero ya te haces una idea. Ahora tenga en cuenta que esto sigue siendo bastante lento ya que tiene una suma doble, que es $\mathcal{O}(n^2)$ operación. Hay técnicas más rápidas que pueden hacer caer esto a $\mathcal{O}(n\log n)$ (por ejemplo, Barnes-Hut ), pero esto puede ser un poco más de lo que desea, dependiendo del tamaño de $n$ .

Si quieres que las partículas se agreguen, tendrás que tenerlo en cuenta durante la integración. Por ejemplo, si la distancia entre dos cuerpos está por debajo de algún umbral, entonces usted necesita averiguar cómo el algoritmo de fusión (por ejemplo, hacer el análisis de colisión para obtener la nueva velocidad y hacer una simple adición para las masas) debe ser insertado en el algoritmo de evolución (probablemente comprobar después de cada paso de tiempo, pero también podría hacer cada pocos pasos). Tal vez quieras ver si hay alguna pregunta sobre detección de colisiones en GameDev.SE para ayudarte en eso, ya que no creo que haya ninguno aquí en Physics.SE.