Maria Paula Osorio Santamaria – 1202448

Informe de Simulación de Colisión de Partículas en Unity

Introducción:

El objetivo de esta simulación es modelar el comportamiento de dos partículas esféricas que están
unidas por un resorte y se encuentran dentro de una esfera contenedora en Unity. Las partículas
tienen masas constantes 𝑚1 𝑦 𝑚2 , respectivamente, y están sujetas a fuerzas de resorte y colisión
con la esfera. Este informe proporciona una explicación detallada de la fuerza experimentada por las
partículas debido al resorte, tanto matemática como físicamente, y presenta la implementación
computacional en Unity.

Fuerza del Resorte:

La fuerza ejercida por el resorte sobre cada partícula se rige por la ley de Hooke y se calcula mediante
la siguiente fórmula:

Donde:

• 𝐹 es la fuerza aplicada.
• 𝑘 es la constante del resorte.
• ∆𝑥 es la deformación o elongación del resorte desde su longitud de equilibrio.

La elongación del resorte se calcula restando la longitud actual del resorte a su longitud inicial. La
dirección de la fuerza del resorte se determina utilizando el vector que une las posiciones de las
partículas, normalizado para mantener su dirección.

Implementación en Unity:

El código en Unity utiliza un enfoque de integración numérica para resolver las ecuaciones de
movimiento de las partículas. A continuación, se destacan las principales partes de la
implementación:

Inicialización:

Las posiciones y velocidades iniciales de las partículas se asignan aleatoriamente dentro de la esfera
contenedora.

Se definen los parámetros de simulación, como la masa, las constantes del resorte y la
amortiguación.
Maria Paula Osorio Santamaria – 1202448

Cálculo de Fuerzas:

Se calculan las fuerzas que actúan sobre las partículas, incluida la gravedad, la fuerza del resorte y la
fuerza de amortiguación.

La fuerza del resorte se calcula para cada partícula en función de la elongación y la dirección del
resorte.

Resolución de Ecuaciones:

Se integran las ecuaciones de movimiento utilizando el método de Euler, actualizando las posiciones
y velocidades de las partículas en cada iteración.

Colisión con la Esfera:

Se detecta y maneja la colisión de las partículas con la esfera contenedora, reflejando sus
velocidades y reposicionándolas dentro de la esfera si es necesario.

Explicación del Código:

using UnityEngine;

public class Simulacion : MonoBehaviour

int N = 2; // Número de partículas

float[,] f; // Estado de las partículas (posiciones y velocidades)

float[,] df; // Derivadas del estado de las partículas (velocidades y aceleraciones)

float masa; // Masa de las partículas

float h; // Paso de tiempo

float ke; // Constante del resorte

float kb; // Constante de amortiguación

float tiempo; // Tiempo actual

float longitudInicial; // Longitud inicial del resorte

GameObject[] misEsferas; // Arreglo para almacenar las esferas visualizadas en Unity

Vector3 gravedad; // Vector de gravedad

float radioEsfera = 10.0f; // Radio de la esfera contenedora

float radioParticula = 0.5f; // Radio de las partículas

Maria Paula Osorio Santamaria – 1202448

float kSpring = 10.0f; // Constante del resorte

void Inicializar()

// Inicializar matrices para almacenar el estado y las derivadas de las partículas

f = new float[N, 6]; // Estado de las partículas (posiciones y velocidades)

df = new float[N, 6]; // Derivadas del estado de las partículas (velocidades y aceleraciones)

h = 0.005f; // Paso de tiempo

tiempo = 0.0f; // Tiempo inicial

masa = 1.0f; // Masa de las partículas

ke = 0.6f; // Constante del resorte

kb = 0.4f; // Constante de amortiguación

gravedad = Vector3.zero; // Gravedad cero

// Inicializar las posiciones y velocidades de las partículas dentro de la esfera contenedora

for (int n = 0; n < N; n++)

Vector3 randomPosition = Random.insideUnitSphere * (radioEsfera - radioParticula);

// Asignar posiciones aleatorias dentro de la esfera contenedora

f[n, 0] = randomPosition.x; // Posición inicial en el eje X

f[n, 1] = randomPosition.y; // Posición inicial en el eje Y

f[n, 2] = randomPosition.z; // Posición inicial en el eje Z

// Inicializar velocidades en cero

f[n, 3] = 0.0f; // Velocidad inicial en el eje X

f[n, 4] = 0.0f; // Velocidad inicial en el eje Y

f[n, 5] = 0.0f; // Velocidad inicial en el eje Z

}
Maria Paula Osorio Santamaria – 1202448

// Actualizar la visualización de las partículas en la escena de Unity

ActualizarVista();

void CalcularVariables()

// Obtener las posiciones y velocidades de las partículas a partir de la matriz 'f'

Vector3[] posicion = new Vector3[N];

Vector3[] velocidad = new Vector3[N];

for (int n = 0; n < N; n++)

posicion[n] = new Vector3(f[n, 0], f[n, 1], f[n, 2]); // Posición de la partícula n

velocidad[n] = new Vector3(f[n, 3], f[n, 4], f[n, 5]); // Velocidad de la partícula n

// Calcular las fuerzas que actúan sobre las partículas

Vector3[] fuerza = new Vector3[N];

for (int n = 0; n < N; n++)

fuerza[n] = Vector3.zero; // Inicializar la fuerza en cero

// Añadir fuerzas externas como la gravedad

fuerza[n] += masa * gravedad;

// Calcular la fuerza del resorte

if (n == 0)

// Calcular la dirección y la elongación del resorte entre las partículas

Maria Paula Osorio Santamaria – 1202448

Vector3 direccionResorte = posicion[1] - posicion[0];

float longitudActual = direccionResorte.magnitude;

float elongacion = longitudActual - longitudInicial;

// Calcular la fuerza del resorte y aplicarla a la partícula n

fuerza[n] += kSpring * elongacion * direccionResorte.normalized;

fuerza[n] -= kb * velocidad[n]; // Fuerza de amortiguación

else if (n == 1)

// Calcular la dirección y la elongación del resorte entre las partículas

Vector3 direccionResorte = posicion[0] - posicion[1];

float longitudActual = direccionResorte.magnitude;

float elongacion = longitudActual - longitudInicial;

// Calcular la fuerza del resorte y aplicarla a la partícula n

fuerza[n] += kSpring * elongacion * direccionResorte.normalized;

fuerza[n] -= kb * velocidad[n]; // Fuerza de amortiguación

// Verificar colisión con la esfera y aplicar fuerzas de rebote si es necesario

if (posicion[n].magnitude + radioParticula > radioEsfera)

// Calcular la dirección normalizada desde el centro de la esfera hasta la posición de la

partícula n

Vector3 direccionNormalizada = posicion[n].normalized;

// Reflejar la velocidad de la partícula n con respecto a la dirección normalizada

velocidad[n] = Vector3.Reflect(velocidad[n], direccionNormalizada);

// Reposicionar la partícula n dentro de la esfera contenedora

posicion[n] = direccionNormalizada * (radioEsfera - radioParticula);

}
Maria Paula Osorio Santamaria – 1202448

// Asignar las fuerzas calculadas a las derivadas del estado de las partículas en 'df'

for (int n = 0; n < N; n++)

for (int i = 0; i < 3; i++)

// Asignar velocidades a las derivadas del estado de las partículas

df[n, i] = velocidad[n][i];

// Calcular y asignar aceleraciones a las derivadas del estado de las partículas

df[n, i + 3] = fuerza[n][i] / masa;

void ResolverEcuaciones()

// Integrar las ecuaciones de movimiento usando el método de Euler

for (int n = 0; n < N; n++)

for (int j = 0; j < 6; j++)

// Actualizar las posiciones y velocidades de las partículas en función de las derivadas

f[n, j] += (df[n, j] * h);

// Avanzar el tiempo por el paso de tiempo 'h'

tiempo += h;

}
Maria Paula Osorio Santamaria – 1202448

void ActualizarVista()

// Actualizar la posición visual de las partículas en la escena de Unity

for (int n = 0; n < N; n++)

// Asignar la posición de la partícula n al objeto visual correspondiente en Unity

misEsferas[n].transform.position = new Vector3(f[n, 0], f[n, 1], f[n, 2]);

void Start()

// Inicializar el arreglo 'misEsferas' para almacenar las referencias a los objetos visuales en Unity

misEsferas = new GameObject[N];

// Buscar y asignar las referencias a los objetos visuales en Unity con nombres 'Sphere1' y
'Sphere2'

for (int n = 0; n < N; n++)

misEsferas[n] = GameObject.Find("Sphere" + (n + 1)); // Ajuste en el nombre de la esfera

longitudInicial = 2.0f; // Establecer la longitud inicial del resorte

// Llamar a la función 'Inicializar' para preparar la simulación

Inicializar();

void Update()
Maria Paula Osorio Santamaria – 1202448

// Calcular las variables necesarias para la simulación en cada cuadro de actualización

CalcularVariables();

// Resolver las ecuaciones de movimiento para avanzar en el tiempo

ResolverEcuaciones();

// Actualizar la visualización de las partículas en la escena de Unity

ActualizarVista();

Conclusiones:

La simulación proporciona una representación visual del comportamiento de las partículas bajo la
influencia del resorte y la colisión con la esfera. La implementación en Unity permite experimentar
con diferentes configuraciones y parámetros para observar cómo afectan al movimiento de las
partículas. Esta simulación sirve como una herramienta útil para comprender conceptos físicos como
la fuerza del resorte y la dinámica de colisión en un entorno virtual interactivo.