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

Ha webszűrőt használsz, győződj meg róla, hogy a *.kastatic.org és a *.kasandbox.org nincsenek blokkolva.

Fő tartalom

A levegő és a folyadék közegellenállása

Súrlódás akkor is van, amikor egy test folyadékban vagy gázban mozog. Ezt az erőt sokféleképpen hívják, de mindegyik nagyjából ugyanazt jelenti: viszkozitás, légellenállás ellenállás, közegellenállás. Bár végül az eredmény hasonló az előző súrlódási példához (a test lelassul), de a közegellenállás kiszámítása egy kicsit más. Nézzük meg a képletet:
Fd=12ρv2ACdv^
Szedjük részeire, és vizsgáljuk meg, mire van szükségünk ahhoz, hogy egy hatásos szimulációt készítsünk ProcessingJS-sel úgy, hogy egyszerűsítünk a képleten.
  • Fd a közegellenállás, az a vektor, amit ki szeretnénk számolni és átadni az applyForce() függvénynek.
  • -1/2 egy konstans: -0,5. Ez nem túl releváns a mi ProcessingJS világunk szempontjából, mivel a többi konstans értéket hasraütéssel úgyis mi fogjuk megállapítani. Azonban fontos, hogy ez egy negatív érték legyen, mert ez azt mondja meg, hogy iránya ellentétes a sebesség irányával (hasonlóan a súrlódáshoz).
  • ρ a görög rho betű, és a folyadék sűrűségét jelöli, ezzel most nem kell törődnünk. Egyszerűsíthetünk, feltételezzük, hogy nem változik, és értéke 1.
  • v a mozgó test sebessége. OK, ez megvan! A test sebessége a sebesség vektor hossza: velocity.mag(). És v2 csupán annyit jelent, hogy v négyzet, vagy v·v.
  • A a folyadékon (vagy gázon) áthaladó test frontális felületének területét jelenti. Egy áramvonalas Lamborghini például kisebb légellenállással találkozik, mint egy szögletes Volvo. Egyenlőre az alapszimuláció esetében a tárgyunkat gömbszerűnek feltételezzük, és ezt a paramétert figyelmen kívül hagyjuk.
  • Cd a közegellenállás együtthatója, hasonlóan a súrlódási együtthatóhoz (μ). Ez egy konstans érték, és az alapján fogjuk beállítani, hogy erős vagy gyenge közegellenállást szeretnénk.
  • A v^ ismerősnek tűnik? Remélem! Ez a sebesség egységvektorra utal, azaz velocity.normalize(). Pont, mint a súrlódásnál, a közegellenállás a sebességgel ellentétes irányba mutat.
Most, hogy az összes alkotórészt megbeszéltük, és megállapítottuk, mire van szükségünk egy egyszerű szimulációhoz, leegyszerűsíthetjük a képletet:
vagy:
// A képlet első része (hossz): v^2 * Cd
var c = 0.1;
var speed = velocity.mag();
var dragMagnitude = c * speed * speed;

// A képlet második fele (irány): v unit vector * -1 
var drag = velocity.get();
drag.normalize();
drag.mult(-1);

// Hossz és irány együtt!
drag.mult(dragMagnitude);
Illesszük be ezt az erőt a Mover objektumtípusunkba még egy kiegészítéssel! Amikor a súrlódásos példánkat készítettük, a súrlódás mindig jelen volt. Amikor a tárgy mozgott, a súrlódás lelassította. Itt adjunk hozzá valamit a környezethez – egy „folyadékot", amelyen a Mover objektumok keresztülhaladnak. A Liquid (folyadék) objektum egy négyszög lesz, ismerjük a helyzetét, szélességét, magasságát és a „közegellenállási együtthatóját" – azaz könnyű rajta áthaladni (mint mondjuk a levegőn), vagy nehéz (például a melaszon). Ezen felül kell még egy függvény, ami felrajzolja a rajzvászonra (és még két függvény, amit hamarosan megtárgyalunk).
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);
};
A főprogram deklarálja és inicializálja az új Liquid objektumpéldányt. Figyeld meg, hogy az együttható értéke alacsony (0,1), egyébként a tárgyunk hamar megállna (lehet olyan helyzet, amikor persze pont ezt szeretnéd)!
var liquid = new Liquid(0, height/2, width, height/2, 0.1);
Most egy érdekes kérdés vetődik fel: hogyan kommunikáljon a Mover objektum a Liquid objektummal? Más szóval az alábbit akarjuk végrehajtani:
Amikor egy mozgó objektum keresztülhalad a folyadékon, közegellenállással találkozik.
... vagy objektumorientált megfogalmazásban (feltételezve, hogy Mover objektumok tömbjében navigálsz egy i indexszel):
// A Mover folyadékban van?
if (liquid.contains(movers[i])) {
    // Számold ki a közegellenállást
    var dragForce = liquid.calculateDrag(movers[i]);
    // Érvényesítsd a közegellenállást a Mover objektumon
    movers[i].applyForce(dragForce);
}
A fenti programrészletből látható, hogy két függvényt kell a Liquid objektumtípushoz hozzáadni: (1) egy olyan függvényt, ami megállapítja, hogy a Mover benne van-e a Liquid objektumban és (2) egy olyan függvényt, ami kiszámolja a közegellenállást, amit a folyadék kifejt a Mover objektumra.
Az első egyszerű: egy olyan feltételes utasítást használunk, amellyel megállapítjuk, hogy a helyzetvektor benne van-e a folyadék négyszögében.
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 drag() függvény egy kicsit bonyolultabb; de már megírtuk ezt a program-részletet. Ez a képlet egyszerűsített implementációja. A közegellenállás egyenlő a közegellenállási együttható szorozva a Mover sebességnégyzetével, a sebességgel ellentétes irányban!
Liquid.prototype.calculateDrag = function(m) {
  // Hossz egyenlő együttható · sebesség négyzet
  var speed = m.velocity.mag();
  var dragMagnitude = this.c * speed * speed;

  // Az irány a sebességgel ellentétes
  var dragForce = m.velocity.get();
  dragForce.mult(-1);

  // A hossz szerint méretezünk 
  dragForce.normalize();
  dragForce.mult(dragMagnitude);
  return dragForce;
};
Miután hozzáadtuk ezt a két függvényt a Liquid objektum típushoz, az egészet összerakjuk egy programba. (A programsorokban található megjegyzések: 1. sor: Dan Shiffman, natureofcode.com példája alapján; 3. sor: Erővektorok (gravitáció és folyadékellenállás); 4. sor: Példa a többszörös erőhatás kezelésére Mover objektumokon; 5. sor: A testekre a gravitáció folyamatosan hat; 6. sor: A testekre a folyadék ellenállás csak akkor hat, amikor a test a „vízben" van; 17. sor: Folyadékban van a Mover?; 24. sor: Közegellenállás számítása; 26. sor: Hossz egyenlő együttható · sebesség négyzet; 30. sor: Az irány a sebességgel ellentétes; 34. sor: A hossz szerint méretezünk; 35. sor: dragForce.setMag(dragMagnitude); 86. sor: Mozgatjuk a testeket; 88. sor: Elkészítjük a folyadék objektumot; 94. sor: Megrajzoljuk a vizet; 99. sor: A Mover folyadékban van?; 101. sor: Közegellenállás kiszámítása; 103. sor: Közegellenállás aktiválása; 107. sor: A gravitáció a tömeg alapján van itt méretezve!; 109. sor: Gravitáció aktiválása; 112. sor: Módosítás és megjelenítés; 123. sor: Mover objektumok véletlenszerű újraindítása; 130. sor: Nem működik???)
Ha futtatod a programot, láthatod, hogy vízbe eső labdákat szimulálunk. A tárgyak csak akkor lassulnak le, amikor a rajzvászon alján található kék területen haladnak át (ami a folyadékot szimbolizálja). Azt is megfigyelheted, hogy a kisebb tárgyak sokkal jobban lelassulnak, mint a nagyobbak, Emlékszel Newton második törvényére? A = F / M. Gyorsulás egyenlő erő osztva tömeg. Egy nagy tömegű tárgy lassabban gyorsul. Egy kisebb tárgy gyorsabban gyorsul. Ebben az esetben a szóban forgó gyorsulás a közegellenállás miatti „lelassulás". A kisebb tárgyak gyorsabban fognak lelassulni, mint a nagyobbak.
Ez a „Természetes szimulációk" tananyag a Daniel Shiffman által készített „The Nature of Code” alapján készült, a Creative Commons Attribution-NonCommercial 3.0 Unported License szerint.

Szeretnél részt venni a beszélgetésben?

Még nincs hozzászólás.
Tudsz angolul? Kattints ide, ha meg szeretnéd nézni, milyen beszélgetések folynak a Khan Academy angol nyelvű oldalán.