If you're seeing this message, it means we're having trouble loading external resources on our website.

Si estás detrás de un filtro de páginas web, por favor asegúrate de que los dominios *.kastatic.org y *.kasandbox.org estén desbloqueados.

Contenido principal

Curso: Programación de computadoras > Unidad 5

Lección 5: Fuerzas
Computación
Programación de computadoras
JS avanzado: simulaciones naturales
Fuerzas
© 2024 Khan AcademyTérminos de usoPolítica de privacidadAviso de cookies

Resistencia del aire y de fluidos

Google Classroom
Diagrama de la resistencia de fluidos alrededor de un avión
La fricción también se produce cuando un cuerpo pasa a través de un líquido o un gas. Esta fuerza tiene muchos nombres diferentes, pero todos significan lo mismo: fuerza viscosa, fuerza de arrastre, resistencia del fluido. Mientras que el resultado es, en última instancia, el mismo que en nuestros ejemplos anteriores de fricción (el objeto se frena), la manera en que calculamos una fuerza de arrastre será ligeramente diferente. Echemos un vistazo a la fórmula:
Fd=−12ρv2ACdv^
Ahora vamos a desglozar esto y ver lo que realmente necesitamos para una simulación eficaz en ProcessingJS, haciendo nosotros mismos una fórmula mucho más simple en el proceso.
  • Fd se refiere a la fuerza de arrastre, el vector que a final de cuentas queremos calcular y pasarle a nuestra función applyForce().
  • -1/2 es una constante: -0.5. Esta es bastante irrelevante en términos de nuestro mundo de ProcessingJS, puesto que estaremos inventando valores para otras constantes de todos modos. Sin embargo, el hecho de que sea negativa es importante, ya que nos dice que la fuerza apunta en la dirección opuesta a la dirección de la velocidad (igual que con la fricción).
  • ρ es la letra griega rho, y se refiere a la densidad del líquido, algo de lo que no nos tenemos que preocupar. Podemos simplificar el problema y considerar que tiene un valor constante de 1.
  • v se refiere a la rapidez del objeto en movimiento. Bueno, ¡esto lo tenemos! La rapidez del objeto es la magnitud del vector de velocidad: velocity.mag(). Y v2 simplemente significa v cuadrada o v∗v.
  • A se refiere al área frontal del objeto que está empujando a través del líquido (o gas). Por ejemplo, un Lamborghini aerodinámico va a experimentar menor resistencia del aire que un Volvo cuadrado. Sin embargo, para una simulación básica, podemos considerar que nuestro objeto es esférico e ignorar este elemento.
  • Cd es el coeficiente de arrastre, exactamente lo mismo que el coeficiente de fricción (μ). Esta es una constante que vamos a determinar con base en si queremos que la fuerza de arrastre sea fuerte o débil.
  • v^ ¿Se te hace familiar? Debería. Esto se refiere al vector unitario de velocidad, es decir, velocity.normalize(). Igual que con la fricción, el arrastre es una fuerza que apunta en la dirección opuesta a la velocidad.
Ya que analizamos cada uno de estos componentes y determinado lo que necesitamos para una simulación sencilla, podemos reducir nuestra fórmula a:
Fórmula simplificada: F_drag = ||v ^ 2|| * c_d * v - 1
o:
// Parte 1 de nuestra fórmula (magnitud): v^2 * Cd
var c = 0.1;
var speed = velocity.mag();
var dragMagnitude = c * speed * speed;

// Parte 2 de nuestra fórmula (dirección): vector unitario v * -1 
var drag = velocity.get();
drag.normalize();
drag.mult(-1);

// ¡Magnitud y dirección juntas!
drag.mult(dragMagnitude);
Vamos a implementar esta fuerza en nuestro tipo de objeto Mover con una adición. Cuando escribimos nuestro ejemplo de fricción, la fuerza de fricción siempre estaba presente. Siempre que un objeto se estaba moviendo, la fricción lo frenaba. Aquí, vamos a introducir un elemento al entorno: un “líquido” por el cual los objetos Mover atraviesan. El objeto Liquid será un rectángulo y sabrá acerca de su ubicación, ancho, alto y “coeficiente de arrastre”: es decir, ¿es fácil para los objetos moverse a través de él (como el aire) o difícil (como la melaza)? Además, debe incluir una función para dibujarse en la pantalla (y dos funciones más, que veremos en un momento).
var Liquid = function(x, y, w, h, c) {
  this.x = x;
  this.y = y;
  this.w = w;
  this.h = h;
  this.c = c;
};

Liquid.prototype.display = function() {
  noStroke();
  fill(50);
  rect(this.x, this.y, this.w, this.h);
};
El programa principal ahora declarará e inicializará una nueva instancia de objeto Liquid. Observa que el coeficiente es bajo (0.1), de lo contrario el objeto se detendría bastante rápido (que puede ser el efecto que quieras algún día).
var liquid = new Liquid(0, height/2, width, height/2, 0.1);
Ahora viene una pregunta interesante: ¿cómo hacemos que el objeto Mover le hable al objeto Liquid? En otras palabras, queremos ejecutar lo siguiente:
Cuando un mover pasa a través de un líquido, experimenta una fuerza de arrastre.
…o en idioma orientado a objetos (suponiendo que estamos iterando sobre un arreglo de objetos Mover con índice i):
// ¿El Mover está en el líquido?
if (liquid.contains(movers[i])) {
    // Calcular fuerza de arrastre
    var dragForce = liquid.calculateDrag(movers[i]);
    // Aplicar fuerza de arrastre al Mover
    movers[i].applyForce(dragForce);
}
El código anterior nos dice que tenemos que agregarle dos funciones al tipo de objeto Liquid: (1) una función que determine si un objeto Mover está dentro del objeto Liquid y (2) una función que calcule la fuerza de arrastre ejercida sobre el objeto Mover.
La primera es fácil; podemos simplemente usar una declaración condicional para determinar si el vector de posición se encuentra dentro del rectángulo definido por el líquido.
Liquid.prototype.contains = function(m) {
    var p = m.position;
    return p.x > this.x && p.x < this.x + this.w &&
         p.y > this.y && p.y < this.y + this.h;
};
La función drag() es un poco más complicada; sin embargo, ya escribimos el código para ella. Esto es simplemente una implementación de nuestra fórmula. ¡La fuerza de arrastre es igual al coeficiente de arrastre multiplicado por la velocidad del Mover al cuadrado en la dirección opuesta a la velocidad!
Liquid.prototype.calculateDrag = function(m) {
  // La magnitud es el coeficiente * velocidad al cuadrado
  var speed = m.velocity.mag();
  var dragMagnitude = this.c * speed * speed;

  // La dirección es opuesta a la de la velocidad
  var dragForce = m.velocity.get();
  dragForce.mult(-1);

  // Se escala de acuerdo con la magnitud
  dragForce.normalize();
  dragForce.mult(dragMagnitude);
  return dragForce;
};
Y con estas dos funciones agregadas al tipo de objeto Liquid, estamos listos para poner todo junto en un solo programa:
Al ejecutar el programa, debes darte cuenta de que estamos simulando pelotas cayendo en agua. Los objetos solo se frenan cuando cruzan a través de la zona azul en la parte inferior de la ventana (que representa al líquido). También te darás cuenta de que los objetos más pequeños se frenan mucho más que los objetos más grandes. ¿Recuerdas la segunda ley de Newton? A = F / M. La aceleración es igual a la fuerza dividida entre la masa. Un objeto masivo se acelerará menos. Un objeto pequeño se acelerará más. En este caso, la aceleración de la que estamos hablando es el “frenado” debido al arrastre. Los objetos más pequeños se frenarán más rápido que los más grandes.
Este curso de "Simulaciones Naturales" es un derivado de "La Naturaleza del Código" por Daniel Shiffman, usado bajo una Licencia Creative Commons Reconocimiento-NoComercial 3.0 Unported.

¿Quieres unirte a la conversación?

Inicia sesión
¿Sabes inglés? Haz clic aquí para ver más discusiones en el sitio en inglés de Khan Academy.