Статистические распределения в двумерном кристалле с треугольной решеткой
Материал из Department of Theoretical and Applied Mechanics
Версия от 19:48, 17 декабря 2015; Вадим Цаплин (обсуждение | вклад)
Виртуальная лаборатория > Статистические распределения в двумерном кристалле с треугольной решеткой
Рассматривается система частиц моделируемых материальными точками с линейным законом взаимодействия в плоскости. Частицы располагаются в треугольной решетке, края свободны. Все частицы и связи одинаковые. Уравнение движения для каждой частицы имеет вид:
где – масса частицы, с – жесткость связи, – вектор перемещения, – единичный вектор, направленный к одной из соседних частиц с индексом :
где – радиус-вектор частицы в начальной конфигурации.
Ось направлена вдоль одного из направлений связей. , шаг интегрирования .
Скачать программу: TriLatLin.zip
Текст программы на языке JavaScript (разработчики Цаплин Вадим, Кривцов Антон):
Файл "TriLatLin.js."
1 function MainTriLatticeTemper()
2 {
3 var ctx_X = canvas_densitas_Vx.getContext("2d");
4 var width_X = canvas_densitas_Vx.width;
5 var height_X = canvas_densitas_Vx.height;
6
7 var ctx_Y = canvas_densitas_Vy.getContext("2d");
8 var width_Y = canvas_densitas_Vy.width;
9 var height_Y = canvas_densitas_Vy.height;
10
11 var ctx_E = canvas_energy.getContext("2d");
12 var width_E = canvas_energy.width;
13 var height_E = canvas_energy.height;
14
15 // частица содержит перемещения и скорости
16
17 var _Vx;
18 var _Vy;
19 var Vx2_sum; // сумма квадратов координат скорости Vx (с весом s)
20 var Vxy_sum; // сумма произведений координат скорости VxVy (с весом s)
21 var Vy2_sum; // сумма квадратов координат скорости Vy (с весом s)
22 var Vx4_sum; // сумма (координат скорости Vx)^4 (с весом s)
23 var Vy4_sum; // сумма (координат скорости Vy)^4 (с весом s)
24 var U1x_sum, U1y_sum;
25 var Vx2_av; // средний Vx^2 c эксп. весом (для графиков)
26 var Vy2_av; // средний Vy^2 c эксп. весом
27
28 var suspended = 0; // вычисление приостановлено == 1
29
30 // массив частиц
31
32 var Arr_prt = [];
33
34 var n1 = 30; // число рядов 1
35 var n2 = 30;
36 var n = n1 * n2; // число частиц
37 //var a = 1; // равновесное расстояние между центрами частиц
38 //var c = 1; // линейная жесткость упругой связи
39 //var m = 1; // масса частицы
40 //var с_m = c/m;
41 var dt_sc_m = 0.005; // шаг интегрирования по времени dt_sc_m = dt*sqrt(c_m)
42
43 // максимальные начальные скорости (в безразмерном времени)
44
45 var Vx = 10;
46 var Vy = 0.1;
47 var Vc_x = 0; // скорость
48 var Vc_y = 0; // центра масс
49
50 var K1 = []; // кин. энергия
51 var P = []; // пот. энергия
52
53 slider_input_X.value = Vx;
54 number_input_X.value = Vx;
55 slider_input_Y.value = Vy;
56 number_input_Y.value = Vy;
57 sV_axis = 0;
58 // var str = "arr=\n";
59
60 var s = 0; // шаг по времени
61 var V_max; // максимальная координата скорости на графике
62 var sV_max; // максимальный корень из координаты скорости на графике
63 var norm = 0; // начальные координаты скорости имеют нормальное распределение == 1
64 var Par = []; // возвращаемое значение функции RandomNorm()
65
66 // Случайные числа с нормальным распределением
67 function RandomNorm() // <(Par[0])^2> == 1, <(Par[1])^2> == 1
68 {
69 var r_RandomNorm = Math.sqrt(-2*Math.log(Math.random()));
70 var fi_RandomNorm = Math.random()*Math.PI*2;
71
72 Par[0] = r_RandomNorm*Math.cos(fi_RandomNorm);
73 Par[1] = r_RandomNorm*Math.sin(fi_RandomNorm);
74 }
75
76 function Restart()
77 {
78 Vx = number_input_X.value;
79 Vy = number_input_Y.value;
80
81 for (var j = 0; j < n2; j++)
82 {
83 Arr_prt[j] = [];
84 //Arr_prt[j] = Array(n1);
85
86 for (var i = 0; i < n1; i++)
87 {
88 if (norm)
89 {
90 RandomNorm();
91 _Vx = Par[0];
92 _Vy = Par[1];
93 }
94 else
95 do
96 {
97 _Vx = 2*Math.random()-1;
98 _Vy = 2*Math.random()-1;
99 }
100 while (_Vx*_Vx+_Vy*_Vy > 1);
101
102 //_Vx *= Vx; // диапазон компоненты скорости от -Vx до Vx
103 //_Vy *= Vy; // диапазон компоненты скорости от -Vy до Vy
104
105 Vc_x += _Vx;
106 Vc_y += _Vy;
107
108 var particle = {};
109 particle.Ux = 0;
110 particle.Uy = 0;
111 particle.Vx = _Vx;
112 particle.Vy = _Vy;
113
114 Arr_prt[j][i] = particle;
115
116 //str += Arr_prt[j][i].Vy + "\n";
117 }
118 }
119
120 Vc_x /= n;
121 Vc_y /= n;
122
123 //alert(str + "Vc_x=" + Vc_x + "\nVc_y=" + Vc_y);
124 //alert("length=" + Arr_prt.length);
125 //var str = "arr=\n";
126
127 // обнуление скорости центра масс
128
129 Vx2_sum = 0;
130 Vy2_sum = 0;
131 Vxy_sum = 0;
132
133 for (var j = 0; j < n2; j++)
134 {
135 for (var i = 0; i < n1; i++)
136 {
137 Arr_prt[j][i].Vx -= Vc_x;
138 Arr_prt[j][i].Vy -= Vc_y;
139
140 //str += Arr_prt[j][i].Vx + "\n";
141 _Vx = Arr_prt[j][i].Vx;
142 _Vy = Arr_prt[j][i].Vy;
143 Vx2_sum += _Vx*_Vx;
144 Vy2_sum += _Vy*_Vy;
145 }
146 }
147
148 // нормировка компонент скорости
149
150 Vx2_sum = Vx/Math.sqrt(Vx2_sum/n);
151 Vy2_sum = Vy/Math.sqrt(Vy2_sum/n);
152
153 for (var j = 0; j < n2; j++)
154 {
155 for (var i = 0; i < n1; i++)
156 {
157 Arr_prt[j][i].Vx *= Vx2_sum;
158 Arr_prt[j][i].Vy *= Vy2_sum;
159 }
160 }
161
162 s = 0;
163
164 sV_max = Math.sqrt(Math.max(Vx, Vy)*2); // максимальное значение абсциссы на графиках
165 V_max = 2*Math.max(Vx, Vy); // максимальное значение абсциссы на графиках
166
167 ExCalculateReset();
168 Vx2_sum = 0; Vy2_sum = 0; Vxy_sum = 0;
169 Vx4_sum = 0; Vy4_sum = 0;
170 U1x_sum = 0; U1y_sum = 0;
171 }
172
173 var k_sen = 0.1; // чувствительность усредненного по времени массива к текущим изменениям
174 span_sen.innerHTML = k_sen;
175
176 //var wait_calc = 0;// без накладок
177
178 function Step()
179 {
180 //if (wait_calc) alert("w!");
181 //wait_calc = 1;
182
183 if (!suspended)
184 {
185 Calculate(); // шаг интегрирования по времени
186 ExCalculate(k_sen); // подготовка для вывода графиков
187
188 s++;
189 Paint(); // рисование графиков
190 }
191 //wait_calc = 0;
192 }
193
194 //Calculate();
195
196 // треугольная решетка
197 // x[j][i] = a*i + a/2*(j&1);
198 // y[j][i] = sqrt(3)/2*a*j;
199
200 var sqrt3 = Math.sqrt(3);
201
202 function Calculate() // шаг интегрирования
203 {
204 var i; var j;
205
206 P[s] = 0;
207
208 for (var k = 0; k < n; k++) // вычисление компонент скорости
209 {
210 i = k%n1;
211 j = Math.floor(k/n1);
212
213 var Ux; var Uy; var U_4; var U_43; var U_1;
214
215 if (j > 0)
216 {
217 var ai = j&1 ? i : i-1; // соседняя частица 1
218
219 if (ai >= 0)
220 {
221 Ux = Arr_prt[j-1][ai].Ux - Arr_prt[j][i].Ux;
222 Uy = Arr_prt[j-1][ai].Uy - Arr_prt[j][i].Uy;
223 U_1 = Ux + Uy*sqrt3;
224 U_4 = U_1 / 4 * dt_sc_m;
225 U_43 = U_4*sqrt3;
226
227 Arr_prt[j][i].Vx += U_4;
228 Arr_prt[j][i].Vy += U_43;
229
230 Arr_prt[j-1][ai].Vx -= U_4;
231 Arr_prt[j-1][ai].Vy -= U_43;
232
233 P[s] += U_1*U_1/8;
234 }
235
236 ai++; // соседняя частица 2
237
238 if (ai < n1)
239 {
240 Ux = Arr_prt[j-1][ai].Ux - Arr_prt[j][i].Ux;
241 Uy = Arr_prt[j-1][ai].Uy - Arr_prt[j][i].Uy;
242 U_1 = Uy*sqrt3 - Ux;
243 U_4 = U_1 / 4 * dt_sc_m;
244 U_43 = U_4*sqrt3;
245
246 Arr_prt[j][i].Vx -= U_4;
247 Arr_prt[j][i].Vy += U_43;
248
249 Arr_prt[j-1][ai].Vx += U_4;
250 Arr_prt[j-1][ai].Vy -= U_43;
251
252 P[s] += U_1*U_1/8;
253 }
254 }
255
256 if (i > 0) // соседняя частица 3
257 {
258 U_1 = Arr_prt[j][i-1].Ux - Arr_prt[j][i].Ux;
259 Ux = U_1 * dt_sc_m;
260
261 Arr_prt[j][i].Vx += Ux;
262 Arr_prt[j][i-1].Vx -= Ux;
263
264 P[s] += U_1*U_1/2;
265 }
266 }
267
268 K1[s] = 0;
269
270 //var Ux, Uy, U_4, U_43, U_1;
271 //alert("Ux=" + Ux + "\nUy=" + Uy + "\nU_1=" + U_1);
272
273 for (var k = 0; k < n; k++) // вычисление перемещений
274 {
275 i = k%n1;
276 //j = k/n1;
277 j = Math.floor(k/n1);
278
279 var Vx_loc = Arr_prt[j][i].Vx;
280 var Vy_loc = Arr_prt[j][i].Vy;
281
282 Arr_prt[j][i].Ux += Vx_loc * dt_sc_m;
283 Arr_prt[j][i].Uy += Vy_loc * dt_sc_m;
284
285 K1[s] += (Vx_loc*Vx_loc+Vy_loc*Vy_loc)/2;
286
287 Vxy_sum += Vx_loc*Vy_loc;
288 //str += Vx + "\n";
289 //str += Vy;
290 Vx_loc *= Vx_loc;
291 Vy_loc *= Vy_loc;
292 Vx2_sum += Vx_loc*s;
293 Vy2_sum += Vy_loc*s;
294
295 Vx_loc *= Vx_loc;
296 Vy_loc *= Vy_loc;
297 Vx4_sum += Vx_loc*s;
298 Vy4_sum += Vy_loc*s;
299
300 //U1x_sum += Arr_prt[j][i].Ux;
301 //U1y_sum += Arr_prt[j][i].Uy;
302 }
303
304 U1x_sum += Arr_prt[0][0].Ux;
305 U1y_sum += Arr_prt[0][0].Uy;
306
307 //var str = "P=" + P;
308 //alert(str);
309 //str = "K=" + K1;
310 //alert(str);
311 }
312
313 var N_graph_Vx = 20;
314 var Vx_dens = []; // массив статистического распределения частиц по компонентам скорости Vx,
315 var Vy_dens = []; // Vy.
316 var sVx_dens = []; // массив статистического распределения частиц по компонентам скорости sqrt(Vx),
317 var sVy_dens = []; // sqrt(Vy).
318
319 function ExCalculateReset()
320 {
321 for (var i = 0; i < N_graph_Vx; i++)
322 {
323 Vx_dens[i] = 0;
324 Vy_dens[i] = 0;
325 sVx_dens[i] = 0;
326 sVy_dens[i] = 0;
327 }
328
329 Vx2_av = 0; Vy2_av = 0;
330
331 ExCalculate(1); // В начальный момент считаются статистические распределения без запаздывания (k_sen == 1)
332 }
333
334 function ExCalculate(k_sen) // статистические вычисления на каждом шаге
335 {
336 var Vx_dens_loc = [];
337 var Vy_dens_loc = [];
338 var sVx_dens_loc = [];
339 var sVy_dens_loc = [];
340
341 for (var i = 0; i < N_graph_Vx; i++)
342 {
343 Vx_dens_loc[i] = 0;
344 Vy_dens_loc[i] = 0;
345 sVx_dens_loc[i] = 0;
346 sVy_dens_loc[i] = 0;
347 }
348
349 var Vx2_av_loc = 0;
350 var Vy2_av_loc = 0;
351
352 ///////////////////////////////////////////////////////////////////////
353
354 for (var k = 0; k < n; k++)
355 {
356 i = k%n1;
357 j = Math.floor(k/n1);
358
359 var Vx_loc = Math.abs(Arr_prt[j][i].Vx);
360 var Vy_loc = Math.abs(Arr_prt[j][i].Vy);
361 var sVx_loc = Math.sqrt(Vx_loc);
362 var sVy_loc = Math.sqrt(Vy_loc);
363
364 var n_d = Math.floor(Vx_loc/V_max*(N_graph_Vx-1)+0.5);
365 if (n_d < N_graph_Vx) { Vx_dens_loc[n_d]++; }
366
367 n_d = Math.floor(Vy_loc/V_max*(N_graph_Vx-1)+0.5);
368 if (n_d < N_graph_Vx) { Vy_dens_loc[n_d]++; }
369
370 n_d = Math.floor(sVx_loc/sV_max*(N_graph_Vx-1)+0.5);
371 if (n_d < N_graph_Vx) { sVx_dens_loc[n_d]++; }
372
373 n_d = Math.floor(sVy_loc/sV_max*(N_graph_Vx-1)+0.5);
374 if (n_d < N_graph_Vx) { sVy_dens_loc[n_d]++; }
375
376 Vx2_av_loc += Vx_loc*Vx_loc;
377 Vy2_av_loc += Vy_loc*Vy_loc;
378 }
379
380 Vx_dens_loc[0] *= 2; Vy_dens_loc[0] *= 2;
381 sVx_dens_loc[0] = 0; sVy_dens_loc[0] = 0;
382
383 Vx2_av_loc /= n; Vy2_av_loc /= n;
384
385 ///////////////////////////////////////////////////////////////////////
386 // интегральный регулятор (фильтр низких частот)
387
388 for (var i = 0; i < N_graph_Vx; i++)
389 {
390 Vx_dens[i] = k_sen*Vx_dens_loc[i] + (1-k_sen)*Vx_dens[i];
391 Vy_dens[i] = k_sen*Vy_dens_loc[i] + (1-k_sen)*Vy_dens[i];
392 sVx_dens[i] = k_sen*sVx_dens_loc[i] + (1-k_sen)*sVx_dens[i];
393 sVy_dens[i] = k_sen*sVy_dens_loc[i] + (1-k_sen)*sVy_dens[i];
394 }
395
396 Vx2_av = k_sen*Vx2_av_loc + (1-k_sen)*Vx2_av;
397 Vy2_av = k_sen*Vy2_av_loc + (1-k_sen)*Vy2_av;
398 }
399
400 function Paint()
401 {
402 Draw(ctx_X, width_X, height_X, sV_axis ? sVx_dens : Vx_dens, 0);
403 Draw(ctx_Y, width_Y, height_Y, sV_axis ? sVy_dens : Vy_dens, 1);
404
405 var Vx2_aver = Vx2_sum / s / (s > 1 ? s-1 : 1) * 2 / n;
406 var Vy2_aver = Vy2_sum / s / (s > 1 ? s-1 : 1) * 2 / n;
407 var Vxy_aver = Vxy_sum / s / (s > 1 ? s-1 : 1) * 2 / n;
408
409 span_Vx2.innerHTML = Vx2_aver.toFixed(3);
410 span_Vy2.innerHTML = Vy2_aver.toFixed(3);
411 span_V2.innerHTML = (Vx2_aver+Vy2_aver).toFixed(3);
412 span_Vxy.innerHTML = Vxy_aver.toExponential(2);//toPrecision(3);
413 //span_U.innerHTML = "< Ux > = " + (U1x_sum/s).toFixed(2) +
414 //"________ < Uy > = " + (U1y_sum/s).toFixed(2);
415
416 var Vx4_aver = Vx4_sum / s / (s > 1 ? s-1 : 1) * 2 / n;
417 var Vy4_aver = Vy4_sum / s / (s > 1 ? s-1 : 1) * 2 / n;
418
419 span_Mx.innerHTML = (Vx4_aver/Vx2_aver/Vx2_aver/3).toFixed(3);
420 span_My.innerHTML = (Vy4_aver/Vy2_aver/Vy2_aver/3).toFixed(3);
421
422 span_k1.innerHTML = ((Vx2_aver+Vy2_aver) / (Vx*Vx+Vy*Vy)).toFixed(3);
423 span_k2.innerHTML = ((Vx2_aver-Vy2_aver) / (Vx*Vx-Vy*Vy)).toFixed(3);
424 span_1k2.innerHTML = ((Vx*Vx-Vy*Vy) / (Vx2_aver-Vy2_aver)).toFixed(3);
425
426 DrawE();
427
428 span_E.innerHTML = ((K1[s-1] + P[s-1])/n).toFixed(2);
429 span_t.innerHTML = (s*dt_sc_m).toFixed(2);
430 span_steps.innerHTML = s;
431 }
432
433 function Draw(ctx, width, height, V_dens, n_col) // рисование графиков распределения частиц по компонентам скорости Vx, Vy
434 {
435 ctx.lineWidth="0.6"; // ширина линии
436 ctx.clearRect(0, 0, width, height); // очистить экран
437
438 var dens_V_max; // максимальное значение плотности
439
440 if (sV_axis)
441 {
442 /*dens_V_max = 1;
443 for (var i = 0; i < N_graph_Vx; i++)
444 if (V_dens[i] > dens_V_max) { dens_V_max = V_dens[i]; }*/
445
446 dens_V_max = n*2*sV_max/(N_graph_Vx-1)*Math.sqrt(Math.sqrt(2/Math.E/(n_col ? Vy2_av : Vx2_av))/Math.PI);
447 }
448 else dens_V_max = n*2*V_max/(N_graph_Vx-1)/Math.sqrt(2*Math.PI*(n_col ? Vy2_av : Vx2_av));
449
450 var x_scal = width / (N_graph_Vx-1); // N_graph_Vx-1 == число промежутков между N_graph_Vx точек
451 var y_scal = height / dens_V_max / (sV_axis ? 1.2 : 1.1); // 1.2,1.1 - коэффициент запаса
452
453 var x = 0; var y;
454 var n_points = Math.floor(width / 3);
455
456 ///////////////////////////////////////////////////////////////////////
457 // рисование нормального распределения
458
459 if (checkbox_norm.checked)
460 {
461 var width2 = width*width;
462
463 if (sV_axis) // распределение по sqrt(V_(x,y))
464 {
465 ctx.strokeStyle = "#006000";
466 ctx.beginPath();
467
468 var x1 = -V_max*V_max/width2/width2/(n_col ? Vy2_av : Vx2_av)/2;
469 var y1 = y_scal*dens_V_max*Math.sqrt(Math.sqrt(2*Math.E/(n_col ? Vy2_av : Vx2_av)))*sV_max/width;
470
471 ctx.moveTo(x, height);
472
473 //for (var i = 1; i < n_points; i++)
474 for (var i = 1; i <= width; i++)
475 {
476 //x = 3*i;
477 x = i;
478 var x2 = x*x;
479
480 y = Math.floor(height - y1*x*Math.exp(x2*x2*x1));
481
482 ctx.lineTo(x, y);
483 }
484
485 //y = Math.floor(height - y1*width*Math.exp(width2*width2*x1));
486 //ctx.lineTo(width, y);
487
488 ctx.stroke();
489 }
490 else // распределение по V_(x,y)
491 {
492 ctx.strokeStyle = "#006000";
493 ctx.beginPath();
494
495 var y1 = y_scal*dens_V_max;// y_scal*n*2*V_max/(N_graph_Vx-1)/Math.sqrt(2*Math.PI*(n_col ? Vy2_av : Vx2_av));
496 var x1 = -V_max*V_max/width/width/(n_col ? Vy2_av : Vx2_av)/2;
497
498 y = Math.floor(height - y1);
499
500 ctx.moveTo(x, y);
501
502 for (var i = 1; i < n_points; i++)
503 {
504 x = 3*i;
505 y = Math.floor(height - y1*Math.exp(x*x*x1));
506
507 ctx.lineTo(x, y);
508 }
509
510 y = Math.floor(height - y1*Math.exp(width*width*x1));
511 ctx.lineTo(width, y);
512
513 ctx.stroke();
514 }
515 }
516
517 ///////////////////////////////////////////////////////////////////////
518 // рисование вычисленного распределения
519
520 ctx.strokeStyle = n_col ? "#ff0000" : "#0000ff";
521 ctx.beginPath();
522
523 x = 0;
524 y = Math.floor(height - y_scal*V_dens[0]);
525
526 ctx.moveTo(x, y);
527
528 for (var i = 1; i < n_points; i++)
529 {
530 y = 0;
531 x = 3*i;
532
533 var j = Math.floor(x/x_scal);
534 var fi = x/x_scal - j; // 0 <= fi < 1
535
536 if (j >= N_graph_Vx-1) alert("error!");
537
538 // интерполяция кубическими сплайнами
539
540 y += V_dens[j] * (fi-1) * (fi-1) * (2*fi+1); // значения
541 y += V_dens[j+1] * fi * fi * (3-2*fi); // в узлах
542
543 var y_d = (j == 0) ? V_dens[1]-V_dens[0] : (V_dens[j+1]-V_dens[j-1])/2;
544
545 y += y_d * (fi-1) * (fi-1) * fi; // производная в левом узле
546
547 y_d = (j == N_graph_Vx-2) ? V_dens[N_graph_Vx-1]-V_dens[N_graph_Vx-2] : (V_dens[j+2]-V_dens[j])/2;
548
549 y += y_d * fi * fi * (fi-1); // производная в правом узле
550
551 y = Math.floor(height - y_scal*y); // линейное отображение в область построения
552 y = Math.max(0, y);
553 y = Math.min(y, height);
554
555 ctx.lineTo(x, y);
556 }
557
558 y = Math.floor(height - y_scal*V_dens[N_graph_Vx-1]);
559 y = Math.min(y, height);
560 ctx.lineTo(width, y);
561 ctx.stroke();
562
563 ///////////////////////////////////////////////////////////////////////
564 }
565
566 var En_area = 2; // 0 - весь график, 1 - начало, 2 - конец
567
568 function DrawE() // рисование графика энергии от времени
569 {
570 // кинетическая:
571
572 ctx_E.strokeStyle="#004000";
573 ctx_E.lineWidth="0.7"; // ширина линии
574 ctx_E.clearRect(0, 0, width_E, height_E); // очистить экран
575 ctx_E.beginPath();
576
577 var K_max = K1[0];
578 var x_scal;
579
580 x_scal = (En_area == 0) ? x_scal = width_E / Math.max(s, 1500) : width_E / 1500;
581
582 var y_scal = height_E / K_max;
583
584 var i0 = (En_area == 2) ? Math.max(0, s-1500) : 0;
585
586 var x = 0;
587 var y = Math.floor(height_E - K1[i0]*y_scal);
588
589 ctx_E.moveTo(x, y);
590
591 var s_max = (En_area == 1) ? Math.min(s, 1500) : s;
592
593 for (var i = i0+1; i < s; i++)
594 {
595 y = Math.floor(height_E - K1[i]*y_scal);
596 x = Math.ceil((i-i0)*x_scal);
597
598 ctx_E.lineTo(x, y);
599 }
600
601 ctx_E.stroke();
602
603 // средняя линия <E> = K(0)/2
604
605 y = Math.floor(height_E - K1[0]*y_scal/2);
606
607 ctx_E.strokeStyle="#000000";
608 ctx_E.beginPath();
609 ctx_E.moveTo(0, y);
610 ctx_E.lineTo(width_E, y);
611 ctx_E.stroke();
612 }
613
614 //slider_sen.oninput = function()
615 slider_sen.onmousemove = function()
616 {
617 k_sen = span_sen.innerHTML = slider_sen.value;
618 };
619 number_input_X.oninput = function()
620 {
621 slider_input_X.value = number_input_X.value;
622 Restart();
623 };
624 slider_input_X.oninput = function()
625 {
626 number_input_X.value = slider_input_X.value;
627 };
628 slider_input_X.onmouseup = function() { Restart(); };
629 number_input_Y.oninput = function()
630 {
631 slider_input_Y.value = number_input_Y.value;
632 Restart();
633 };
634 slider_input_Y.oninput = function()
635 {
636 number_input_Y.value = slider_input_Y.value;
637 };
638 slider_input_Y.onmouseup = function() { Restart(); };
639 reset_calc.onclick = function()
640 {
641 if (suspended) suspend_calc.onclick();
642 Restart();
643 };
644 suspend_calc.onclick = function()
645 {
646 suspended = !suspended;
647 var str = suspend_calc.value;
648 suspend_calc.value = suspend_calc.name;
649 suspend_calc.name = str;
650 };
651 number_input_n1.oninput = function()
652 {
653 if (number_input_n1.value >= 10)
654 {
655 slider_input_n1.value = number_input_n1.value;
656 span_n1.innerHTML = " x " + number_input_n1.value;
657 n2 = n1 = number_input_n1.value;
658 n = n1*n2;
659
660 span_n.innerHTML = n;
661 Restart();
662 }
663 };
664 slider_input_n1.oninput = function()
665 {
666 number_input_n1.value = slider_input_n1.value;
667
668 if (slider_input_n1.value >= 10)
669 {
670 span_n1.innerHTML = " x " + number_input_n1.value;
671 span_n.innerHTML = number_input_n1.value*number_input_n1.value;
672 }
673 };
674 slider_input_n1.onmouseup = function()
675 {
676 number_input_n1.value = slider_input_n1.value;
677
678 if (slider_input_n1.value >= 10)
679 {
680 span_n1.innerHTML = " x " + number_input_n1.value;
681 n2 = n1 = number_input_n1.value;
682 n = n1*n2;
683
684 span_n.innerHTML = n;
685 Restart();
686 }
687 };
688 radio_V.onchange = function() { sV_axis = 0; span_sqrt1.innerHTML = span_sqrt2.innerHTML = ""; Paint(); };
689 radio_sV.onchange = function() { sV_axis = 1; span_sqrt1.innerHTML = span_sqrt2.innerHTML = "sqrt"; Paint(); };
690 radio_CV.onchange = function() { norm = 0; Restart(); };
691 radio_NV.onchange = function() { norm = 1; Restart(); };
692 checkbox_norm.onclick = function() { Paint(); };
693 radio_En_all.onchange = function() { En_area = 0; Paint(); };
694 radio_En_begin.onchange = function() { En_area = 1; Paint(); };
695 radio_En_end.onchange = function() { En_area = 2; Paint(); };
696
697 Restart();
698 setInterval(Step, 1000 / 30); // функция step будет запускаться 30 раз в секунду (в 1000 мс)
699 }
Файл "TriLatLin.html"
1 <!DOCTYPE html>
2 <html>
3 <head>
4 <title>Треугольная Решетка</title>
5 <script src="TriLatLin.js"></script>
6 <!link rel="stylesheet" type="text/css" href="js_tm_styles.css" />
7 </head>
8 <body onload="MainTriLatticeTemper();">
9 <p>Количество частиц:
10 <input type="range" id="slider_input_n1"
11 min=10 max=300 value=30 step=1 style="width: 160px;">
12 <span id="span_n">900</span> (<input type="number"
13 id="number_input_n1" min=10 max=300 value=30 step=1 style="width: 50px;">
14 <span id="span_n1"> x 30</span> рядов).
15 </p>
16
17 <p>Начальные перемещения частиц – нулевые.</p>
18 <p>Начальное распределение вектора скорости частиц – случайное, с плотностью:</p>
19
20 <p><input type="radio" id="radio_CV" name="dens" checked />
21 Равномерная плотность внутри эллипса <I><B>V<SUB>x</SUB></B></I><SUP>2</SUP> /
22 <I><B>V<SUB>x,max</SUB></B></I><SUP>2</SUP> + <I><B>V<SUB>y</SUB></B></I><SUP>2</SUP> /
23 <I><B>V<SUB>y,max</SUB></B></I><SUP>2</SUP> = 1; 0 вне эллипса,<br>
24 <input type="radio" id="radio_NV" name="dens" />
25 Нормальное распределение плотности.</p>
26
27 <p>Задаваемые начальные среднеквадратические значения σ (<I><B>V<SUB>x</SUB></B></I>(0)) и
28 σ (<I><B>V<SUB>y</SUB></B></I>(0)) указаны под графиками.</p>
29
30 <p><B>Распределение частиц по компонентам скорости <I>V<SUB>x</SUB></I> (слева)
31 и <I>V<SUB>y</SUB></I> (справа).</B></p>
32
33 <p><input type="radio" id="radio_V" name="axis" checked />
34 Оси абсцисс – |<I><B>V<SUB>x</SUB></B></I>| и |<I><B>V<SUB>y</SUB></B></I>|
35 (масштаб одинаковый).<br>
36 <input type="radio" id="radio_sV" name="axis" />
37 Оси абсцисс – sqrt|<I><B>V<SUB>x</SUB></B></I>| и sqrt|<I><B>V<SUB>y</SUB></B></I>|
38 (масштаб одинаковый).</p>
39
40 <p>Оси ординат – плотности распределения частиц.</p>
41 <p><input type=checkbox id=checkbox_norm checked />Изобразить нормальное распределение с дисперсией,
42 равной дисперсии вычисляемой плотности.</p>
43
44 <table>
45 <tr><td><I>P</I></td>
46 <td><canvas id="canvas_densitas_Vx" width="300" height="200" style="border:
47 1px solid #000000"></canvas></td>
48 <td><canvas id="canvas_densitas_Vy" width="300" height="200" style="border:
49 1px solid #000000"></canvas></td>
50 <td><input type="range" orient="vertical" id="slider_sen" min=0.1 max=1 value=0.1 step=0.1
51 style="height: 160px; width: 30px; -webkit-appearance: slider-vertical;" /></td>
52 <td>Чувствительность<br> к мгновенным изменениям<br><span id="span_sen"></span></td>
53 </tr>
54 <tr><td></td><td style="text-align: center"><span id = "span_sqrt1"></span>|<I><B>V<SUB>x</SUB></B></I>|</td>
55 <td style="text-align: center"><span id = "span_sqrt2"></span>|<I><B>V<SUB>y</SUB></B></I>|</td>
56 </tr>
57 <tr><td></td><td></td><td></td></tr>
58 <tr><td></td><td></td><td></td></tr>
59 <tr><td></td><td></td><td></td></tr>
60 <tr><td></td>
61 <td><input type="range" id="slider_input_X" min=0 max=10 value=2 step=0.1
62 style="width: 160px;" />σ (<I><B>V<SUB>x</SUB></B></I>(0)) =<input type="number"
63 id="number_input_X" min=0 max=10 value=2 step=0.1 style="width: 50px;" /></td>
64 <td><input type="range" id="slider_input_Y" min=0 max=10 value=2 step=0.1
65 style="width: 160px;" />σ (<I><B>V<SUB>y</SUB></B></I>(0)) =<input type="number"
66 id="number_input_Y" min=0 max=10 value=2 step=0.1 style="width: 50px;" /></td>
67 </tr>
68 </table>
69
70 <br>
71 <input type="button" id="reset_calc" value="Старт">
72 <input type="button" id="suspend_calc" value="Приостановить" name = "Возобновить">
73 <br>
74
75 <p>Средние значения <I><B>V<SUB>x</SUB></B></I><SUP>2</SUP> и
76 <I><B>V<SUB>y</SUB></B></I><SUP>2</SUP> по всем частицам.<br>
77 (Усреднение производится также по времени с весом, пропорциональным времени):</p>
78
79 <I><B>T<SUB>xx</SUB></B><SUP>S</SUP></I> =
80 < <I><B>V<SUB>x</SUB></B></I><SUP>2</SUP> > = <span id="span_Vx2"></span>
81 <br>
82 <I><B>T<SUB>yy</SUB></B><SUP>S</SUP></I> =
83 < <I><B>V<SUB>y</SUB></B></I><SUP>2</SUP> > = <span id="span_Vy2"></span>
84 <br>
85 < <I><B>V<SUB>x</SUB></B></I><SUP>2</SUP> > + < <I><B>V<SUB>y</SUB></B></I><SUP>2</SUP> > = <span id="span_V2"></span>
86 <br>
87 < <I><B>V<SUB>x</SUB>V<SUB>y</SUB></B></I> > = <span id="span_Vxy"></span>
88 <br>
89
90 <p>Отношение моментов распределения компонент скорости:<br>
91 Для нормального распределения
92 < <I><B>V</B></I><SUP>4</SUP> > / < <I><B>V</B></I><SUP>2</SUP> ><SUP>2</SUP> / 3 = 1</p>
93 < <I><B>V<SUB>x</SUB></B></I><SUP>4</SUP> > / < <I><B>V<SUB>x</SUB></B></I><SUP>2</SUP> ><SUP>2</SUP> / 3 =
94 <span id="span_Mx"></span><br>
95 < <I><B>V<SUB>y</SUB></B></I><SUP>4</SUP> > / < <I><B>V<SUB>y</SUB></B></I><SUP>2</SUP> ><SUP>2</SUP> / 3 =
96 <span id="span_My"></span><br>
97
98 <p>Отношение стационарных и начальных квадратов компонент скорости:</p>
99 <I><B>T<SUB>xx</SUB></B><SUP>S</SUP></I> + <I><B>T<SUB>yy</SUB></B><SUP>S</SUP></I> =
100 <I>k</I><SUB>1</SUB>
101 (<B><I>T<SUB>xx</SUB></I></B><SUP>0</SUP> + <B><I>T<SUB>yy</SUB></I></B><SUP>0</SUP>)
102 <br>
103 <I><B>T<SUB>xx</SUB></B><SUP>S</SUP></I> – <I><B>T<SUB>yy</SUB></B><SUP>S</SUP></I> =
104 <I>k</I><SUB>2</SUB>
105 (<B><I>T<SUB>xx</SUB></I></B><SUP>0</SUP> – <B><I>T<SUB>yy</SUB></I></B><SUP>0</SUP>)
106 <br>
107
108 <I>k</I><SUB>1</SUB> = <span id="span_k1"></span><br>
109 <I>k</I><SUB>2</SUB> = <span id="span_k2"></span><br>
110 (1/<I>k</I><SUB>2</SUB> = <span id="span_1k2"></span>)
111
112 <!span id="span_U"> <!/span> <!br>
113 <p><B>Изменение кинетической энергии во времени.</B> Горизонтальная линия – половина полной энергии.</p>
114 <canvas id="canvas_energy" width="1000" height="300" style="border: 1px solid #000000"></canvas>
115 <br>
116 <input type="radio" id="radio_En_all" name="radio_En" />График целиком.
117 <input type="radio" id="radio_En_begin" name="radio_En" />Начало графика.
118 <input type="radio" id="radio_En_end" name="radio_En" checked />Окончание графика.
119
120 <p>Полная энергия, приходящаяся на одну частицу: <I>E</I> = <span id="span_E"> </span>.
121 <br>
122 Время <I>t</I> = <span id="span_t"> </span> (<span id="span_steps"></span> шагов)</p>
123 </body>
124 </html>
