4.3. Fuerzas

Una vez que se entiende cómo funcionan los vectores y cómo estos pueden representar nociones como la velocidad y la aceleración, toca centrarse en entender cómo se pueden mover objetos por la ventana de Processing, pero respondiendo estos a diferentes fuerzas que aparezcan en un determinado medioambiente.

La definición de fuerza que interesa en esta explicación es la que indica que una fuerza es un vector que causa que un objeto con una determinada masa se acelere.

Revisar las tres leyes que Issac Newton utilizó para describir diferentes características de nuestro mundo físico y que relacionan el movimiento con el concepto de fuerza generará un basamento desde donde trabajar con ciertos modelos.

La primera ley de Newton dice lo siguiente:

En un entorno real existen muchas fuerzas que afectan directamente al movimiento de un objeto. La fuerza de gravedad, la fuerza del viento y la resistencia del aire son solo algunas de ellas. Todas estas fuerzas actuarán para mantener una situación de equilibrio que se puede romper al aplicar una determinada fuerza (tirar una pelota hacia arriba, por ejemplo) y que en determinado tiempo (dependiendo la fuerza que hayamos aplicado) volverá al estado de equilibrio.

Dentro de Processing esto se traduce en que el vector de velocidad (PVector) se mantendrá constante mientras exista un estado de equilibrio.

La segunda ley de Newton es quizás la ley más importante para modelar dentro de Processing. Esta ley es la que indica que la fuerza es igual a la masa de un objeto por su aceleración, tal como lo indica la siguiente ecuación:

F = M x A

De esta notación debe interpretarse que F y A son vectores y eso se indica con una flecha por encima de la letra correspondiente. La masa de un cuerpo no es un vector porque no tiene una dirección específica. Lo interesante de esta ley es que se puede expresar de diferentes formas con el solo hecho de despejar los términos a conveniencia. Así, se pueden tener las siguientes variantes:

Se despeja la masa:



Se despeja la aceleración:

A =¯ M

En esta última se observa que la aceleración es directamente proporcional a la fuerza e inversamente proporcional a la masa. O sea, si la fuerza aumenta, aumenta la aceleración y si la masa aumenta, disminuye la aceleración.

Una vez dilucidada esta relación es necesario entender cuál es la diferencia entre el peso de un objeto y su masa.

La masa de un objeto es una medida de la cantidad de materia que tiene ese objeto (eso lo medimos en kilogramos, por ejemplo). El peso de un objeto es técnicamente la fuerza de gravedad sobre este (se mide en newtons). Otra medida que se puede realizar sobre un objeto es su densidad que es la cantidad de masa por unidad de volumen (por ejemplo: gramos por centímetro cúbico).

La pregunta es ¿cómo se entiende la masa en Processing? Porque en realidad se están dibujando píxeles, que no tienen masa. Por lo tanto, para empezar, en un principio todos los objetos en Processing tienen una masa igual a 1. Por lo tanto, la aceleración es igual a la fuerza que se aplica. Esto en un primer intento que simplificará bastante las cosas. La ecuación anterior quedará simplificada de la siguiente manera:

A = F

Como se observó con anterioridad, la clase mover tenía los siguientes campos principales:

Class mover
{
PVector ubicacion;
PVector velocidad;
PVector aceleracion;
}

La nueva meta es ahora poder escribir un método que ayude a aplicar las diferentes fuerzas que intervienen en un determinado entorno, por ejemplo, la fuerza del viento o la gravedad. Pero antes de eso es conveniente revisar la tercera ley de Newton.

La tercera ley de Newton se refiere a una situación de equilibrio, ya que indica que para cualquier acción existe una reacción opuesta. Esta ley se puede entender mejor si se habla de un par acción/reacción. Las fuerzas siempre van de a pares, siempre tienen la misma magnitud, pero en direcciones opuestas.

En Processing, si se calcula un PVector f que es la fuerza de un objeto A sobre un objeto B, se debe también aplicar la fuerza contraria (PVector.mult(f, -1)) que B ejerce sobre A.

Siempre que se trabaje en Processing se debe tener en cuenta que no se calcula en todo momento todas las fuerzas que se ejercen en cada uno de los objetos, sino que se aplica un modelo que se aproxima a ese comportamiento y que muchas veces es bastante general. De esta manera, se obtiene un resultado muy próximo al buscado, pero sin consumir muchos recursos.

4.3.1. Aplicando fuerzas

El método para aplicar fuerzas a un movimiento estará conformado de la siguiente manera:

Void FuerzaAplicada(PVector fuerza)
{
aceleración.add(fuerza);
}

Esto indica que la aceleración se verá afectada por una acumulación de las fuerzas que se apliquen con esta función, ya que estas se irán sumando vectorialmente. De esta manera, se pueden aplicar diferentes tipos de fuerza y estas afectarán la aceleración, que luego afectará la velocidad y, luego, la ubicación.

Para que la fuerza aplicada termine por afectar la ubicación, es necesario actualizar todos los valores, y por eso se escribe un nuevo método, que realizará esta tarea:

void actualizar
{
velocidad.add(aceleracion);
ubicación.add(velocidad);
aceleración.mult(0);
}

La última multiplicación que se realiza sobre la aceleración asegura que solamente se aplicará la fuerza una sola vez, de otra manera, la velocidad crecería sin parar y ese no es el efecto deseado.

 

4.3.2. Trabajando con masas

Una vez que se sabe cómo aplicar fuerzas, sería interesante tener la opción de configurar los valores de masa de la clase. Para esto, se agrega un campo más, que será un float, ya que, como se indicó anteriormente, la masa no tiene dirección:

class mover
{
PVector ubicacion;
PVector velocidad;
PVector aceleracion;
float masa;
}

Al involucrar la masa hay que cambiar sensiblemente el método FuerzaAplicada, ya que, como se sabe, la fuerza es inversamente proporcional a la masa:

Void FuerzaAplicada (PVector fuerza)
{
fuerza.div(masa);
aceleracion.add(fuerza);
}

Sin embargo, esta forma de realizar la operación no es la correcta, ya que si se tienen dos instancias de la clase mover (lo cual es muy probable si se desea tener más de un objeto), se verá afectada directamente la fuerza que se aplica.
Un ejemplo:

mover m1 = new mover();
mover m2 = new mover();
PVector viento = new PVector(1,0);
m1.FuerzaAplicada(viento);
m2. FuerzaAplicada(viento);

Cuando se aplica por primera vez la fuerza del viento, esta es directamente dividida por la masa y, por lo tanto, su valor se reduce y luego ese nuevo valor de fuerza del viento se aplica a la siguiente instancia de la clase mover.

Por lo tanto, para no cambiar la fuerza del viento al aplicar cada vez el método AplicarFuerza se debe escribir este método de la siguiente manera:

void AplicarFuerza(PVector fuerza)
{
//Primero se hace una copia del vector que se desea aplicar
PVector f = fuerza.get();
//Y luego se usa este para realizar la operación. De esta manera no
//se verá afectado el vector inicial.
f.div(masa);
aceleracion.add(f);
}

4.3.3. Creando fuerzas de la nada

Anteriormente se explicó cómo aplicar las diferentes fuerzas a los objetos que se crean en el programa, pero todavía no está claro cómo generar esas fuerzas. Se trabajará entonces con dos formas de crearlas dentro del programa.

En el primer caso, usando el viento como ejemplo, si se tiene un determinado objeto creado a partir de la clase mover, y se aplica una fuerza, se puede hacer que esta fuerza tenga valores por defecto, y así comenzar su aplicación desde un punto inicial:

//Se crea el objeto a partir de la clase
mover objeto = new mover();
//Se preconfigura el valor de una fuerza
PVector viento = new PVector(0.01, 0);
//Se aplica esa fuerza
Objeto.FuerzaAplicada(viento);

Otro ejemplo que se puede revisar es el de la fuerza de gravedad. Es sabido que si se tiran dos pelotas de diferente masa desde un edificio, ambas llegarán al piso al mismo tiempo.

Esto sucede porque, como se observó con anterioridad, la aceleración aplicada a un objeto es inversamente proporcional a la masa de ese objeto (se divide por la masa de ese objeto) y la fuerza de gravedad es directamente proporcional a la masa de ese objeto (se multiplica por la masa de un objeto). Si se aplican ambas fuerzas, la de la gravedad y la aceleración que se produce, la masa del objeto se cancela y ya las fuerzas aplicadas no dependen de este parámetro.

Entonces, aplicar la fuerza de gravedad y la aceleración en el programa no es tan complicado. Para probar que se cumple lo que se remarcó antes, se usarán dos objetos de la clase mover, con diferentes masas, así se podrán comparar ambos resultados:

//Se crean dos objetos.
mover objeto1 = new mover();
mover objeto2 = new mover();

//Se inicializa el vector del viento.
PVector viento = new PVector(0.001,0);

//Se obtiene de cada objeto.
float m1 = objeto1.mass;
float m2 = objeto2.mass;

//Se inicializan los dos vectores correspondientes a la gravedad de cada
//objeto.
//Al fin y al cabo dará el mismo valor.
PVector gravedad1 = new PVector(0,0.1*m1);
PVector gravedad2 = new PVector(0,0.1*m2);

//Se aplican las fuerzas, se actualizan y se craquean los bordes para cada
//objeto.
objeto1.FuerzaAplicada(viento);
objeto2.FuerzaAplicada(viento);

objeto1.FuerzaAplicada(gravedad1);
objeto2.FuerzaAplicada(gravedad2);

objeto1.actualizar();
objeto2.actualizar();

objeto1.mostrar();
objeto2.mostrar();

objeto1.detectarBordes();
objeto2.detectarBordes();

 

La segunda forma de generar una fuerza es modelándola. Es menos directa que la anterior ya que se debe tomar una fórmula matemática y pasarla a código, pero es bastante efectiva a la hora de ser aplicada y presenta rasgos que se acercan a los comportamientos reales. Como ejemplo se utilizará la noción de fricción y su fórmula.

Según su definición, la fricción es una fuerza disipativa. Esto significa que al aplicar esta fuerza, la totalidad de la energía de un sistema decrece cuando un objeto está en movimiento. Un ejemplo sería una bicicleta. Cuando esta está en movimiento se utilizan los frenos para reducir la velocidad o pararla. Los frenos aprietan la rueda utilizando la fricción para realizar el frenado. Además, cuando se está andando en bicicleta, la energía cinética, producida por el movimiento, se convierte en energía calórica debido a que el aire también produce rozamiento. Ambas fuerzas son un ejemplo de fricción.

Un modelo completo de la aplicación de la fricción debería incluir casos separados de fricción estática (un cuerpo en reposo sobre una superficie) y la fricción cinética (un cuerpo en movimiento sobre una superficie). En este caso en particular, solo se utilizará la fricción cinética. La fórmula de fricción es la siguiente:



Pero ¿qué son estos signos y qué significan? La F por supuesto representa la fricción; representa al vector de velocidad (esa es otra notación utilizada para indicar vectores); μ (la letra griega “mu”) sirve para representar el coeficiente de fricción, el cual varía dependiendo de la superficie en la cual se desplaza el vehículo (si este es alto, la fricción es más fuerte: en bloque de hielo, por ejemplo, tiene un coeficiente de fricción muy bajo); la N de esta fórmula representa la fuerza normal, o sea, la fuerza perpendicular al objeto en movimiento a lo largo de la superficie en la que se desplaza. Pensándolo un poco, cuando se conduce un vehículo por un determinado camino, este se aferra al piso gracias a la fuerza de gravedad, y también, como se revisó en la tercera ley de Newton, a su vez el camino también empuja contra el vehículo. Esta última es la que se determina como fuerza normal.

Por último, existe un factor -1 que multiplica a toda la fórmula. Este factor determina la dirección del vector de fuerza de la fricción, el cual va en sentido contrario al de velocidad.

Una vez determinados todos los componentes de la fórmula de fricción, se debe descubrir cuáles componentes determinan la magnitud del vector fricción y cuáles, la dirección. En la dirección del vector intervendrán el vector de velocidad y el factor -1, como se dijo anteriormente. En la magnitud intervendrán los factores restantes μ * N, el coeficiente de fricción y la fuerza normal.

A continuación, una manera de representar y calcular ambos elementos en el lenguaje de Processing.

//coeficiente de fricción arbitrario
float c = 0.01;
//fuerza normal arbitraria
float normal = 1;

//Se calcula la magnitud del vector de fricción
float frictionMag = c*normal;

//Se calcula la dirección del vector de fricción
PVector friccion = velocity.get();
//Se multiplica por el factor -1
friccion.mult(-1);
//Se normaliza la fricción tal cual se hizo antes
friccion.normalize();

//Por último se multiplican todos los términos como lo indica la fórmula
friccion.mult(frictionMag);

De esta manera, se parte de la ecuación que representa la fricción y se modela la misma en lenguaje Processing.

En las siguientes secciones, se trabajará sobre otros modelos de fuerzas, específicamente la resistencia del aire y algunos fluidos y la atracción gravitacional.

 

4.3.4. Modelo de resistencia del aire y los fluidos

La fricción ocurre también cuando un cuerpo pasa a través de un líquido o un gas. Estas fuerzas tienen diferentes nombres, pero en realidad son la misma cosa: fuerza viscosa, fuerza de arrastre, resistencia a los fluidos, etc. Si bien el resultado es el mismo al que se arriba con la fórmula de fricción anterior (el objeto ralentiza su movimiento) la manera en que se calcula la fuerza de arrastre es ligeramente diferente. Esta es la fórmula que se utiliza en este caso:



Esta ecuación parece más compleja que la anterior, pero al descomponerla y observar de qué se trata cada factor, es más fácil trabajar con ella. Descomponer una fórmula y encontrar el significado de cada factor es la forma más sencilla de modelar la fuerza mediante un lenguaje de programación.

Por lo tanto, esta es la descripción de los elementos que conforman la fórmula:

	se refiere a la fuerza de arrastre en sí, es el vector que se aplica al objeto.
	es una constante (-0.5). El valor en sí de esta constante es irrelevante en el mundo creado en Processing, pero el hecho de que sea negativa produce un cambio substancial en el modelo. Esto indica, como en el caso anterior, que la fuerza que se está calculando es opuesta a la dirección de la velocidad.
p	es la letra griega “rho”, y se refiere a la densidad del líquido (cantidad de masa contenida en un determinado volumen). Si bien se puede tener cualquier valor de densidad, para simplificar, se determinará este factor con un valor constante de 1.
v	se refiere a la velocidad del objeto en movimiento. En realidad solo se trata de la magnitud de la velocidad (velocidad.magnitude()). En la fórmula interviene el cuadrado de la velocidad.
A	se refiere al área frontal del objeto que se impulsa a través del líquido. Esto depende de cuán aerodinámico o no es el objeto. En este caso, se considera al objeto esférico, por lo tanto, muy aerodinámico, por lo que se ignorará este elemento de la fórmula.
	es el coeficiente de resistencia, y es ni más ni menos que una constante que se determina en función de si se quiere que la fuerza de arrastre sea fuerte o débil.
	es el vector unidad de velocidad. Como en el caso de la fricción el arrastre es una fuerza que está en oposición a la velocidad.

Como antes, se determina qué componentes de la ecuación se utilizan para calcular la magnitud y cuáles componentes serán necesarios para el cálculo de la dirección de la fuerza.

Igual que antes, la dirección estará determinada por el conjunto entre el vector de velocidad y la densidad del líquido p, cuyo valor es 1. A su vez, se indicará un signo negativo, porque justamente la resistencia del aire o líquido será contraria en dirección al vector de velocidad. Entonces quedaría:

Dirección de la fuerza de arrastre = * - 1

La magnitud estará conformada por los elementos que quedan, exceptuando a los que se ignoran:

Magnitud de la fuerza de arrastre =

En Processing, esto se resume de la siguiente manera:

//Coeficiente de fricción
float c = 0.1;
//Magnitud del vector de velocidad
float velocidad = v.mag();

//Magnitud del vector de arrastre, coeficiente por la magnitud de la
//velocidad al cuadrado
float MagnitudArrastre = c * speed * speed;

//Y la dirección de la velocidad, normalizada y multiplicada por -1
PVector arrastre = velocidad.get();
arrastre.mult(-1);
arrastre.normalize();
arrastre.mult(MagnitudArrastre);

 

4.3.5. Modelo de atracción gravitacional

Si bien se tiene una experiencia diaria con la fuerza de gravedad, quizás no se llega a entender con facilidad cómo, en realidad, funciona esta fuerza. Se sabe que si se levanta un objeto del suelo y luego se lo suelta, este se precipita hacia el suelo de nuevo, hasta alcanzar el reposo. Se tiende a creer que la fuerza de gravedad es solamente la atracción que la tierra produce en los objetos, pero la realidad es que tanto la tierra como los objetos son atraídos mutuamente. La diferencia es que la tierra es tan grande con respecto a los objetos diarios, que la diferencia de atracción es monstruosa. Entonces, la idea de que todo objeto con masa ejerce una fuerza gravitatoria sobre cualquier otro objeto, se desprende de que si tenemos dos objetos, ambas masas serán parte de la ecuación que modela esta fuerza.

La siguiente ecuación es la que calcula las fuerzas ejercidas por la gravitación de dos objetos:



Al descomponer los diferentes elementos de la ecuación se puede entender de qué se trata esta ecuación:

F	se refiere a la fuerza gravitatoria, es el vector de fuerza que se busca calcular para luego aplicarlo al movimiento del objeto.
G	es la constante de gravitación universal, la cual determina la intensidad de la fuerza de atracción gravitatoria entre los cuerpos. Esta constante se define de la siguiente manera:

metros cúbicos por kilogramo por segundo al cuadrado.

Sin embargo, como en general se crearán entornos nuevos, esta constante puede ser variada de la forma que se desee. En este caso se igualará a 1.

m1 y m2	son las masas de los objetos 1 y 2. Estas masas pueden ser ignoradas también en un principio. Luego se hará hincapié en ellas y en su aplicación para darle más características al entorno desarrollado.
	se refiere al vector unidad que apunta desde el objeto 1 hacia el objeto 2. Se revisará cómo calcular este vector mediante la resta entre la ubicación de un objeto y otro.
	se refiere a la distancia entre los dos objetos elevada al cuadrado. Como este elemento está dividiendo a todo lo demás, la fuerza de atracción será menor cuanto más lejos estén los objetos, y mayor cuando estén más cerca.

A esta altura, la ecuación que modela la atracción gravitatoria es un poco más entendible. A continuación, se presenta una forma de traducirla a lenguaje Processing.

En primera instancia, se necesita saber la posición de los dos objetos que se atraen. Para esto se definen dos vectores con la posición de los objetos:

PVector posicion1;
PVector posicion2;

Luego, se necesitan las masas de ambos objetos, estos serán float:

float masa1;
float masa2;

Y luego se define otro float para la constante de gravitación universal:

float G;

A partir de esto, se va a calcular la fuerza de gravedad dividiendo el problema en dos partes, primero se procesa la dirección r y luego la intensidad de la fuerza de acuerdo con la masa y la distancia.

Debido a que un vector es la diferencia entre dos puntos, se puede obtener la dirección de la fuerza de atracción restando las posiciones de los dos objetos y luego normalizando el resultado. De esa manera, se obtiene un vector unidad que contiene la dirección hacia donde se sienten atraídos los objetos. En Processing eso se logra de la siguiente manera:

PVector direccion = PVector.sub(ubicación1,ubicación2);
direccion.normalize();

Ahora, para obtener la magnitud de la fuerza de atracción se escala el vector de dirección de acuerdo con la ecuación en la que intervienen las masas de los objetos que se atraen y luego se multiplica por el vector dirección que se calculó anteriormente:

float m = (G * masa1 * masa2) / (distancia * distancia);
direccion.mult(m);

Lo único que faltaría estimar es la distancia a la que se encuentran ambos objetos. Esto es muy sencillo ya que la distancia entre dos puntos es justamente la magnitud de un vector. En ese caso, se utiliza la resta vectorial de las dos posiciones, nuevamente, pero esta vez para obtener solamente la magnitud, esta será la distancia:

PVector fuerza = PVector.sub(ubicacion1,ubicacion2);

//El largo del vector indica la magnitud del mismo, y esta, a su vez, es la
//distancia entre los dos objetos
float distancia = fuerza.magnitude();
//Se calcula nuevamente la intensidad de la gravedad
float m = (G * masa1 * masa2) / (distancia * distancia);
//Si se normaliza el vector fuerza luego de haber usado su magnitud, se
//obtiene la dirección, todo en un solo paso. Luego se aplica esa dirección
//a la fuerza gravitatoria
fuerza.normalize();
fuerza.mult(m);

 

Conclusiones

En esta clase se han revisado conceptos básicos de física que aportan a los programas la posibilidad de generar movimientos más acordes a la realidad. Mediante diferentes modelos se pueden generar medioambientes que estén influenciados por la velocidad del viento, la fuerza de gravedad, la fricción con determinados objetos o el cambio de un tipo de fluido a otro. La aplicación de estos modelos ha producido un cambio de paradigma en los últimos años en lo que se refiere a simulaciones para videojuegos, y estos se han extendido a las instalaciones multimediales. Algunos juegos como “The Incredible Machine”, “Angry Birds” o “Candy Crush” han sido partícipes de un conjunto de juegos dados a llamar “juegos físicos” o “Physics Games”. Estos juegos han logrado combinar la física, el arte y el entretenimiento a través de diseños innovadores y niveles de jugabilidad extremos.

Es interesante pensar en estos desarrollos como parte importante del software art, ya que generan conocimiento que puede ser utilizado de forma directa en diversas formas de arte.