ძირითადი მასალა
კომპიუტერული პროგრამირება
კურსი: კომპიუტერული პროგრამირება > თემა 5
გაკვეთილი 5: ძალები- ნიუტონის მოძრაობის კანონები
- გამოწვევა: საჰაერო ბუშტი
- ბევრი ობიექტის მოძრაობა
- გამოწვევა: კედელთან ბურთის თამაში
- გრავიტაციისა და ხახუნის ილუსტრაცია
- გამოწვევა: სიჩქარის შესამცირებელი ზღუდეები ქუჩაში
- ჰაერისა და სითხის წინაღობა
- გამოწვევა: ჩაძირული მორები
- გრავიტაციული მიზიდულობა
- გამოწვევა: ხელოვნების ნიმუშის შექმნა
- ორმხრივი მიზიდულობა
- გამოწვევა: ორმხრივი განზიდულობა
- პროექტი: არსებების კომფორტი და ცახცახი
© 2023 Khan Academyგამოყენების პირობებიკონფიდენციალურობის პოლიტიკაშენიშვნა ქუქი-ჩანაწერებზე
ჰაერისა და სითხის წინაღობა
ხახუნი მაშინაც წარმოიქმნება, როცა სხეული გადის სითხეში ან აირად სხეულში. ამ ძალას აქვს ბევრი განსხვავებული სახელი, თითოეულ მათგანს ერთი და იგივე მნიშვნელობა აქვს: ბლანტსითხიანი ხახუნის ძალა, ბლანტი ხახუნის ძალა, დენადი წინაღობა. საბოლოო შედეგი იგივეა, რაც ხახუნის წინა მაგალითებში (ობიექტი ნელდება), მაგრამ გზა, რომლითაც ვითვლით ბლანტი ხახუნის ძალას, ოდნავ განსხვავებულია. შევხედოთ ფორმულას:
ახლა ნაწილებად დავყოთ ეს და ვნახოთ, რეალურად რა გვჭირდება 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()
-ს. ზუსტად ისე, როგორც ხახუნის შემთხვევაში, ბლანტი ხახუნი არის ძალა, რომელიც სიჩქარის საპირისპიროდ არის მიმართული.
ახლა, როცა გავააანალიზეთ თითოეული კომპონენტი და გავარკვიეთ, რა გვჭირდება მარტივი სიმულაციისათვის, შეგვიძლია, ჩვენი ფორმულა დავიყვანოთ შემდეგნაირად:
ან:
// ჩვენი ფორმულის პირველი ნაწილი (სიდიდე): 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.
გსურთ, შეუერთდეთ დისკუსიას?
პოსტები ჯერ არ არის.