Resistência do ar e dos fluidos

Atrito também ocorre quando um corpo passa através de um líquido ou gás. Esta força tem muitos nomes diferentes, todos realmente significando a mesma coisa: força viscosa, força de arrasto, resistência do fluido. Enquanto o resultado no final é o mesmo que nossos exemplos anteriores de atrito (retarda o objeto), a maneira pela qual calculamos a força de arrasto será ligeiramente diferente. Vejamos a fórmula:

F_{d} = - \frac{1}{2} ρ v^{2} A C_{d} \hat{v}

Agora vamos decompô-la e ver o que nós realmente precisamos para uma simulação eficiente em ProcessingJS, criando uma fórmula mais simples.

$F_{d}$ ‍ se refere a força de arrasto, o vetor que, no fim das contas, queremos calcular e passar para nossa função applyForce().
-1/2 é uma constante: -0,5. Isso é relativamente irrelevante no nosso mundo de ProcessingJS, já que vamos inventar valores para as constantes. No entanto, o fato de ser negativo é importante, pois nos diz que a força está na direção oposta à velocidade (assim como o atrito).
$ρ$ ‍ é a letra Grega rho, e se refere à densidade do líquido, algo com o qual não precisamos nos preocupar. Podemos simplificar o problema e considerar isso como um valor constante igual a 1.
$v$ ‍ se refere à velocidade do objeto em movimento. Ok, isso nós temos! A velocidade do objeto é a magnitude do vetor de velocidade: velocity.mag(). E $v^{2}$ ‍ significa apenas $v$ ‍ ao quadrado ou $v * v$ ‍.
$A$ ‍ se refere à área frontal do objeto que empurrado através do líquido (ou gás). Uma Lamborghini aerodinâmica, por exemplo, vai sofrer menos resistência do ar do que um Volvo Boxy. Mesmo assim, para uma simulação básica, podemos considerar que nosso objeto é esférico e ignorar esse elemento.
$C_{d}$ ‍ é o coeficiente do arrasto, que é exatamente o mesmo coeficiente do atrito (μ). Isso é uma constante que vamos determinar de acordo com nossa vontade de que a força de arrasto seja forte ou fraca.
$\hat{v}$ ‍ parece familiar? Pois deve parecer. Isso se refere ao vetor unitário velocidade, isto é, velocity.normalize(). Assim como o atrito, o arrasto é a força que aponta na direção oposta à velocidade.

Agora que nós analisamos cada um desses elementos e determinamos o que precisamos para uma simulação simples, nós podemos reduzir nossa fórmula para:

ou:

// Parte 1 de nossa fórmula (magnitude): v^2 * Cd
var c = 0.1;
var speed = velocity.mag();
var dragMagnitude = c * speed * speed;

// Parte 2 de nossa fórmula (direção): v unit vector * -1 
var drag = velocity.get();
drag.normalize();
drag.mult(-1);

// Magnitude e direção juntos!
drag.mult(dragMagnitude);

Vamos implementar essa força no nosso objeto de tipo Mover com um acréscimo. Quando nós escrevemos o nosso exemplo de atrito, a força de atrito estava sempre presente. Sempre que um objeto estava se movendo, o atrito iria desacelerá-lo. Aqui, vamos introduzir um elemento ao nosso ambiente — um “líquido” pelo qual os objetos Mover passam. O objeto Liquid vai ser um retângulo e nós vamos saber a sua localização, largura, altura, e o “coeficiente de arrasto”—ou seja, é fácil para os objetos passarem por ele (como ar) ou difícil (como melaço)? Além disso, ele deve incluir uma função para se desenhar na tela (e duas outras funções, que veremos em um 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);
};

O programa principal vai agora declarar e inicializar uma nova instância do objeto Liquid. Note que o coeficiente é pequeno (0,1), caso contrário o objeto iria parar relativamente rápido (o que pode ser algum dia o efeito que você deseja).

var liquid = new Liquid(0, height/2, width, height/2, 0.1);

Agora vem uma questão interessante: como conseguimos fazer com que o objeto Mover converse com o objeto Liquid? Em outras palavras, queremos executar o seguinte:

Quando um objeto em movimento passa por um líquido ele é sujeito à uma força de arrasto.

…ou em programação orientada a objetos (assumindo que nós estamos percorrendo um vetor de objetos Mover com índice i):

// O Mover está no líquido?
if (liquid.contains(movers[i])) {
    // Calcula a força de arrasto
    var dragForce = liquid.calculateDrag(movers[i]);
    // Aplica a força de arrasto ao Mover
    movers[i].applyForce(dragForce);
}

O código acima nos diz que nós devemos adicionar duas funções ao objeto do tipo Liquid: (1) uma função que determina se um objeto Mover está dentro do objeto Liquid, e (2) uma função que calcula a força de arrasto exercida sobre o objeto Mover.

A primeira é fácil; podemos simplesmente usar uma instrução condicional para determinar se o vetor de localização está dentro do retângulo definido pelo 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;
};

A função drag() é um pouco mais complicada; porém, nós já escrevemos o código para ela. Essa é simplesmente uma implementação da nossa fórmula. A força de arrasto é igual ao coeficiente de arrasto multiplicado pela velocidade do Mover ao quadrado na direção oposta à velocidade!

Liquid.prototype.calculateDrag = function(m) {
  // Magnitude é o coeficiente * velocidade ao quadrado
  var speed = m.velocity.mag();
  var dragMagnitude = this.c * speed * speed;

  // Direção é o inverso da velocidade
  var dragForce = m.velocity.get();
  dragForce.mult(-1);

  // Escala de acordo com a magnitude
  dragForce.normalize();
  dragForce.mult(dragMagnitude);
  return dragForce;
};

E com essas duas funções adicionadas ao objeto de tipo Liquid, nós estamos prontos para colocar tudo junto em um programa:

Ao executar o programa, você deve perceber que estamos simulando bolas caindo na água. Os objetos só começam a reduzir a velocidade quando estão atravessando a área azul na parte inferior da janela (que representa o líquido). Você também vai perceber que objetos menores perdem velocidade mais rápido do que objetos maiores. Lembra-se da segunda lei de Newton? A = F / M. A aceleração é igual à força dividida pela massa. Um objeto massivo vai acelerar menos. Um objeto menor vai acelerar mais. Nesse caso, a aceleração da qual estamos falando é a “redução de velocidade” que se deve ao arrasto. Os objetos menores vão reduzir sua velocidade com uma taxa maior do que os objetos maiores.

Este curso "Natural Simulations" é um derivado do "The Nature of Code" por Daniel Shiffman, usado sob a Creative Commons Attribution-NonCommercial 3.0 Unported License.

Quer participar da conversa?

Entrar

Classificar por:

Nenhuma postagem por enquanto.

Você entende inglês? Clique aqui para ver mais debates na versão em inglês do site da Khan Academy.