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

თუ ვებფილტრს იყენებთ, დარწმუნდით, რომ *.kastatic.org და *.kasandbox.org დომენები არ არის დაბლოკილი.

ძირითადი მასალა

კომპიუტერული პროგრამირება

ჰაერისა და სითხის წინაღობა

თვითმფრინავის ირგვლივ არსებული დენადი წინაღობის დიაგრამა
ხახუნი მაშინაც წარმოიქმნება, როცა სხეული გადის სითხეში ან აირად სხეულში. ამ ძალას აქვს ბევრი განსხვავებული სახელი, თითოეულ მათგანს ერთი და იგივე მნიშვნელობა აქვს: ბლანტსითხიანი ხახუნის ძალა, ბლანტი ხახუნის ძალა, დენადი წინაღობა. საბოლოო შედეგი იგივეა, რაც ხახუნის წინა მაგალითებში (ობიექტი ნელდება), მაგრამ გზა, რომლითაც ვითვლით ბლანტი ხახუნის ძალას, ოდნავ განსხვავებულია. შევხედოთ ფორმულას:
F, start subscript, d, end subscript, equals, −, start fraction, 1, divided by, 2, end fraction, rho, v, squared, A, C, start subscript, d, end subscript, v, with, hat, on top
ახლა ნაწილებად დავყოთ ეს და ვნახოთ, რეალურად რა გვჭირდება ProcessingJS-ში ეფექტური სიმულაციისთვის, ამავდროულად შევქმნათ ჩვენთვის ბევრად უფრო ადვილი ფორმულა.
  • F, start subscript, d, end subscript აღნიშნავს ბლანტი ხახუნის ძალას — ვექტორს, რომლის გამოთვლაც და ჩვენს applyForce() ფუნქციაში გადაცემა გვინდა საბოლოოდ.
  • -1/2 არის მუდმივა: -0,5. ეს საკმაოდ არარელევანტურია ProcessingJS-ის სამყაროსთვის, რადგან ჩვენ ისედაც მოვიფიქრებთ მნიშვნელობებს სხვა მუდმივებისთვის. მიუხედავად ამისა, ფაქტი, რომ ის უარყოფითია, მნიშვნელოვანია, რადგან ეს გვეუბნება, რომ ძალა არის სიჩქარის საწინააღმდეგოდ მიმართული (ზუსტა ისე, როგორც ხახუნის შემთხვევაში).
  • rho არის ბერძნული ასო რო და ის აღნიშნავს სითხის სიმკვრივეს, ამაზე არ უნდა ვიდარდოთ. შეგვიძლია, გავამარტივოთ ამოცანა და ჩავთვალოთ, რომ მას აქვს მუდმივი მნიშვნელობა 1.
  • v აღნიშნავს მოძრავი ობიექტის სიჩქარეს. კარგი, ეს გავიგეთ! ობიექტის სიჩქარე არის სიჩქარის ვექტორის სიდიდე: velocity.mag(). ხოლო v, squared, უბრალოდ, ნიშნავს კვადრატში აყვანილ v-ს, იგივე v, times, v-ს.
  • A აღნიშნავს სითხეში (ან აირში) მოძრავი ობიექტის წინა ნაწილის ფართობს. მაგალითად, აეროდინამიკურ ლამბორგინიზე იმოქმედებს ჰაერის უფრო ნაკლები წინაღომა, ვიდრე ყუთის ფორმის მქონე ვოლვოზე. მარტივი სიმულაციისთვის შეგვიძლია, მივიჩნიოთ, რომ ჩვენი ობიექტი არის სფეროს ფორმის, და ყურადღება არ მივაქციოთ ამ ელემენტს.
  • C, start subscript, d, end subscript არის ბლანტი ხახუნის კოეფიციენტი, ზუსტად იგივე, რაც ხახუნის კოეფიციენტი (μ). ეს არის მუდმივა, რომელსაც განვსაზღვრავთ იმის მიხედვით, გვინდა თუ არა, ბლანტი ხახუნის ძალა იყოს ძლიერი.
  • v, with, hat, on top გეცნობათ? უნდა გეცნობოდეთ. ეს აღნიშნავს სიჩქარის ერთეულოვან ვექტორს, ანუ velocity.normalize()-ს. ზუსტად ისე, როგორც ხახუნის შემთხვევაში, ბლანტი ხახუნი არის ძალა, რომელიც სიჩქარის საპირისპიროდ არის მიმართული.
ახლა, როცა გავააანალიზეთ თითოეული კომპონენტი და გავარკვიეთ, რა გვჭირდება მარტივი სიმულაციისათვის, შეგვიძლია, ჩვენი ფორმულა დავიყვანოთ შემდეგნაირად:
გამარტივებული ფორმულა: F_drag = ||v^2|| * c_d * v - 1
ან:
// ჩვენი ფორმულის პირველი ნაწილი (სიდიდე): v^2 * Cd
var c = 0{,}1;
var speed = velocity.mag();
var dragMagnitude = c * speed * speed;

// ჩვენი ფორმულის მეორე ნაწილი (მიმართულება): v ერთეულოვანი ვექტორი * -1 
var drag = velocity.get();
drag.normalize();
drag.mult(-1);

// სიდიდე და მიმართულება ერთად!
drag.mult(dragMagnitude);
მოდით, განვახორციელოთ ამ ძალის იმპლემენტაცია ჩვენს Mover ობიექტის ტიპში ერთი რამის დამატებით. როდესაც ჩვენ დავწერეთ ჩვენი ხახუნის მაგალითი, ხახუნის ძალა ყოველთვის მოქმედებდა. ყოველთვის, როცა ობიექტი მოძრაობდა, ხახუნი მას ანელებდა. აქ, მოდით, გარემოს წარვუდგინოთ ელემენტი - „სითხე", რომელშიც Mover ობიექტები გადიან. Liquid ობიექტი იქნება მართკუთხედი და მას ეცოდინება მისი ადგილმდებარეობა, სიგანე, სიმაღლე და „ბლანტი ხახუნის კოეფიციენტი“ — ანუ, ობიექტისთვის ადვილია მასში (მაგალითად, ჰაერში) გავლა თუ ძნელი (მაგალითად, მელასაში)? დამატებით, ის უნდა მოიცავდეს საკუთარი თავის ეკრანზე დახატვის ფუნქციას (და კიდევ ორ ფუნქციას, რომელთაც მალე განვიხილავთ).
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);
};
მთავარი პროგრამა ახლა გამოაცხადებს და ინიციალიზაციას გაუკეთებს ახალ Liquid ობიექტის ნიმუშს. აღვნიშნოთ, რომ კოეფიციენტი არის დაბალი (0,1), წინააღმდეგ შემთხვევაში, ობიექტი შეჩერდებოდა ძალიან მალე (რისი გაკეთებაც, შეიძლება, ოდესმე მოგინდეთ).
var liquid = new Liquid(0, height/2, width, height/2, 0{,}1);
ახლა მოდის საინტერესო შეკითხვა: როგორ ვალაპარაკოთ Mover ობიექტი Liquid ობიექტთან? სხვა სიტყვებით რომ ვთქვათ, გვინდა, რომ განვახორციელოთ შემდეგი რამ:
როდესაც მოძრავი სხეული გადის სითხეში, ის განიცდის ბლანტი ხახუნის წინაღობის ძალას.
…ან ობიექტზე ორიენტირებულ ენაზე (დაშვებული გვაქვს, რომ გადავუყვებით Mover ობიექტების მასივს ინდექსით i):
// Mover სითხეშია?
if (liquid.contains(movers[i])) {
    // გამოვთვალოთ ბლანტი ხახუნის ძალა
    var dragForce = liquid.calculateDrag(movers[i]);
    // გამოვიყენოთ ბლანტი ხახუნის ძალა Mover-ზე
    movers[i].applyForce(dragForce);
}
ზემოთ მოცემული კოდი გვეუბნება, რომ უნდა დავამატოთ ორი ფუნქცია Liquid ობიექტის ტიპს: (1) ფუნქცია, რომელიც არკვევს, არის თუ არა Mover ობიექტი Liquid-ის შიგნით, და (2) ფუნქცია, რომელიც გამოითვლის Mover ობიექტზე მოქმედ ბლანტი ხახუნის ძალას.
პირველი ადვილია: შეგვიძლია, გამოვიყენოთ პირობითი დებულება იმის გამოსარკვევად, მდებარეობს თუ არა ადგილმდებარეობის ვექტორი სითხის მიერ განსაზღვრული მართკუთხედის შიგნით.
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;
};
drag() ფუნქცია ოდნავ უფრო რთულია; მიუხედავად ამისა, მისი კოდი უკვე დაწერილი გვაქვს. ეს, უბრალოდ, არის ჩვენი ფორმულის იმპლემენტაცია. ბლანტი ხახუნის ძალა უდრის შემდეგს: ბლანტი ხახუნის კოეფიციენტი გამრავლებული Mover-ის სიჩქარის მნიშვნელობის კვადრატზე სიჩქარის საპირისპირო მიმართულებით!
Liquid.prototype.calculateDrag = function(m) {
  // სიდიდე არის კოეფიციენტი * სიჩქარის კვადრატი
  var speed = m.velocity.mag();
  var dragMagnitude = this.c * speed * speed;

  // მიმართულება არის სიჩქარის შებრუნებული
  var dragForce = m.velocity.get();
  dragForce.mult(-1);

  // სკალირება სიდიდის მიხედვით
  dragForce.normalize();
  dragForce.mult(dragMagnitude);
  return dragForce;
};
და მას შემდეგ, რაც ეს 2 ფუნქცია დავამატეთ Liquid ობიექტის ტიპს, მზად ვართ, ყველაფერს თავი მოვუყაროთ ერთ პროგრამაში:
პროგრამის გაშვების შემდეგ, ალბათ, შეამჩნიეთ, რომ ჩვენ ვაკეთებთ წყალში ბურთების ჩავარდნის სიმულაციას. ობიექტები ნელდებიან მხოლოდ მაშინ, როცა კვეთენ ფანჯრის ქვედა ნაწილში მყოფ ლურჯ არეს (ეს სითხეს წარმოადგენს). აგრეთვე შეამჩნევდით, რომ პატარა ობიექტები გაცილებით უფრო სწრაფად ნელდებიან, ვიდრე დიდები. გახსოვთ ნიუტონის მეორე კანონი? A = F / M. აჩქარება უდრის ძალას, გაყოფილს მასაზე. ძალიან დიდი მასის მქონე ობიექტი უფრო ნაკლებად ჩქარდება. უფრო პატარა ობიექტი უფრო მეტად ჩქარდება. ამ შემთხვევაში, აჩქარება გულისხმობს „შენელებას" ბლანტი ხახუნის გამო. პატარა ობიექტები შენელდებიან უფრო დიდი ტემპით, ვიდრე დიდები.

ეს „ბუნებრივი სიმულაციების" კურსი ეფუძნება დანიელ შიფმენის წიგნს "კოდის ბუნებას", ის გამოყენებულია ლიცენზიით Creative Commons Attribution-NonCommercial 3,0 Unported License.