Статистические распределения в двумерном кристалле с треугольной решеткой — различия между версиями

Материал из Department of Theoretical and Applied Mechanics
Перейти к: навигация, поиск
м
Строка 26: Строка 26:
 
Скачать программу: [[Медиа:TriLatLin.zip | TriLatLin.zip]]
 
Скачать программу: [[Медиа:TriLatLin.zip | TriLatLin.zip]]
  
Разработчики [[Цаплин Вадим]], [[Кривцов Антон]]
+
<div class="mw-collapsible mw-collapsed">
 +
'''Текст программы на языке JavaScript (разработчики [[Цаплин Вадим]], [[Кривцов Антон]]):''' <div class="mw-collapsible-content">
 +
Файл '''"TriLatLin.js."'''
 +
<syntaxhighlight lang="javascript" line start="1" enclose="div">
 +
function MainTriLatticeTemper()
 +
{
 +
  var ctx_X = canvas_densitas_Vx.getContext("2d");
 +
  var width_X = canvas_densitas_Vx.width;
 +
  var height_X = canvas_densitas_Vx.height;
 +
 
 +
  var ctx_Y = canvas_densitas_Vy.getContext("2d");
 +
  var width_Y = canvas_densitas_Vy.width;
 +
  var height_Y = canvas_densitas_Vy.height;
 +
 
 +
  var ctx_E = canvas_energy.getContext("2d");
 +
  var width_E = canvas_energy.width;
 +
  var height_E = canvas_energy.height;
 +
 
 +
  // частица содержит перемещения и скорости
 +
 
 +
  var _Vx;
 +
  var _Vy;
 +
  var Vx2_sum; // сумма квадратов координат скорости Vx (с весом s)
 +
  var Vxy_sum; // сумма произведений координат скорости VxVy (с весом s)
 +
  var Vy2_sum; // сумма квадратов координат скорости Vy (с весом s)
 +
  var Vx4_sum; // сумма (координат скорости Vx)^4 (с весом s)
 +
  var Vy4_sum; // сумма (координат скорости Vy)^4 (с весом s)
 +
  var U1x_sum, U1y_sum;
 +
  var Vx2_av;  // средний Vx^2 c эксп. весом (для графиков)
 +
  var Vy2_av;  // средний Vy^2 c эксп. весом
 +
 
 +
  var suspended = 0; // вычисление приостановлено == 1
 +
 
 +
  // массив частиц
 +
 
 +
  var Arr_prt = [];
 +
 
 +
  var n1 = 30; // число рядов 1
 +
  var n2 = 30;
 +
  var n = n1 * n2; // число частиц
 +
  //var a = 1; // равновесное расстояние между центрами частиц
 +
  //var c = 1; // линейная жесткость упругой связи
 +
  //var m = 1; // масса частицы
 +
  //var с_m = c/m;
 +
  var dt_sc_m = 0.005; // шаг интегрирования по времени dt_sc_m = dt*sqrt(c_m)
 +
 
 +
  // максимальные начальные скорости (в безразмерном времени)
 +
 
 +
  var Vx = 10;
 +
  var Vy = 0.1;
 +
  var Vc_x = 0; // скорость
 +
  var Vc_y = 0; // центра масс
 +
 
 +
  var K1 = []; // кин. энергия
 +
  var P = []; // пот. энергия
 +
 
 +
  slider_input_X.value = Vx;
 +
  number_input_X.value = Vx;
 +
  slider_input_Y.value = Vy;
 +
  number_input_Y.value = Vy;
 +
  sV_axis = 0;
 +
  // var str = "arr=\n";
 +
 
 +
  var s = 0;  // шаг по времени
 +
  var V_max;  // максимальная координата скорости на графике
 +
  var sV_max;  // максимальный корень из координаты скорости на графике
 +
  var norm = 0; // начальные координаты скорости имеют нормальное распределение == 1
 +
  var Par = []; // возвращаемое значение функции RandomNorm()
 +
 
 +
  // Случайные числа с нормальным распределением
 +
  function RandomNorm() // <(Par[0])^2> == 1, <(Par[1])^2> == 1
 +
  {
 +
var r_RandomNorm = Math.sqrt(-2*Math.log(Math.random()));
 +
var fi_RandomNorm = Math.random()*Math.PI*2;
 +
 
 +
Par[0] = r_RandomNorm*Math.cos(fi_RandomNorm);
 +
Par[1] = r_RandomNorm*Math.sin(fi_RandomNorm);
 +
  }
 +
 
 +
  function Restart()
 +
  {
 +
Vx = number_input_X.value;
 +
Vy = number_input_Y.value;
 +
 
 +
for (var j = 0; j < n2; j++)
 +
{
 +
Arr_prt[j] = [];
 +
//Arr_prt[j] = Array(n1);
 +
 
 +
for (var i = 0; i < n1; i++)
 +
{
 +
if (norm)
 +
{
 +
RandomNorm();
 +
_Vx = Par[0];
 +
_Vy = Par[1];
 +
}
 +
else
 +
do
 +
{
 +
_Vx = 2*Math.random()-1;
 +
_Vy = 2*Math.random()-1;
 +
}
 +
while (_Vx*_Vx+_Vy*_Vy > 1);
 +
 
 +
//_Vx *= Vx; // диапазон компоненты скорости от -Vx до Vx
 +
//_Vy *= Vy; // диапазон компоненты скорости от -Vy до Vy
 +
 
 +
Vc_x += _Vx;
 +
Vc_y += _Vy;
 +
 
 +
var particle = {};
 +
particle.Ux = 0;
 +
particle.Uy = 0;
 +
particle.Vx = _Vx;
 +
particle.Vy = _Vy;
 +
 
 +
Arr_prt[j][i] = particle;
 +
 
 +
//str += Arr_prt[j][i].Vy + "\n";
 +
}
 +
}
 +
 
 +
Vc_x /= n;
 +
Vc_y /= n;
 +
 
 +
//alert(str + "Vc_x=" + Vc_x + "\nVc_y=" + Vc_y);
 +
//alert("length=" + Arr_prt.length);
 +
//var str = "arr=\n";
 +
 
 +
// обнуление скорости центра масс
 +
 
 +
Vx2_sum = 0;
 +
Vy2_sum = 0;
 +
Vxy_sum = 0;
 +
 
 +
for (var j = 0; j < n2; j++)
 +
{
 +
for (var i = 0; i < n1; i++)
 +
{
 +
Arr_prt[j][i].Vx -= Vc_x;
 +
Arr_prt[j][i].Vy -= Vc_y;
 +
 
 +
//str += Arr_prt[j][i].Vx + "\n";
 +
_Vx = Arr_prt[j][i].Vx;
 +
_Vy = Arr_prt[j][i].Vy;
 +
Vx2_sum += _Vx*_Vx;
 +
Vy2_sum += _Vy*_Vy;
 +
}
 +
}
 +
 
 +
// нормировка компонент скорости
 +
 
 +
Vx2_sum = Vx/Math.sqrt(Vx2_sum/n);
 +
Vy2_sum = Vy/Math.sqrt(Vy2_sum/n);
 +
 
 +
for (var j = 0; j < n2; j++)
 +
{
 +
for (var i = 0; i < n1; i++)
 +
{
 +
Arr_prt[j][i].Vx *= Vx2_sum;
 +
Arr_prt[j][i].Vy *= Vy2_sum;
 +
}
 +
}
 +
 
 +
        s = 0;
 +
 
 +
sV_max = Math.sqrt(Math.max(Vx, Vy)*2); // максимальное значение абсциссы на графиках
 +
V_max = 2*Math.max(Vx, Vy); // максимальное значение абсциссы на графиках
 +
 
 +
ExCalculateReset();
 +
Vx2_sum = 0; Vy2_sum = 0; Vxy_sum = 0;
 +
Vx4_sum = 0; Vy4_sum = 0;
 +
U1x_sum = 0; U1y_sum = 0;
 +
  }
 +
 
 +
  var k_sen = 0.1; // чувствительность усредненного по времени массива к текущим изменениям
 +
  span_sen.innerHTML = k_sen;
 +
 
 +
  //var wait_calc = 0;// без накладок
 +
 
 +
  function Step()
 +
  {
 +
      //if (wait_calc) alert("w!");
 +
      //wait_calc = 1;
 +
 
 +
      if (!suspended)
 +
      {
 +
Calculate();    // шаг интегрирования по времени
 +
ExCalculate(k_sen);  // подготовка для вывода графиков
 +
 
 +
s++;
 +
Paint();            // рисование графиков
 +
      }
 +
      //wait_calc = 0;
 +
  }
 +
 
 +
  //Calculate();
 +
 
 +
  // треугольная решетка
 +
  // x[j][i] = a*i + a/2*(j&1);
 +
  // y[j][i] = sqrt(3)/2*a*j;
 +
 
 +
  var sqrt3 = Math.sqrt(3);
 +
 
 +
  function Calculate() // шаг интегрирования
 +
  {
 +
      var i; var j;
 +
 
 +
      P[s] = 0;
 +
 
 +
      for (var k = 0; k < n; k++) // вычисление компонент скорости
 +
      {
 +
        i = k%n1;
 +
        j = Math.floor(k/n1);
 +
 
 +
        var Ux; var Uy; var U_4; var U_43; var U_1;
 +
 
 +
        if (j > 0)
 +
        {
 +
            var ai = j&1 ? i : i-1; // соседняя частица 1
 +
 
 +
            if (ai >= 0)
 +
            {
 +
              Ux = Arr_prt[j-1][ai].Ux - Arr_prt[j][i].Ux;
 +
              Uy = Arr_prt[j-1][ai].Uy - Arr_prt[j][i].Uy;
 +
              U_1 = Ux + Uy*sqrt3;
 +
              U_4 = U_1 / 4 * dt_sc_m;
 +
              U_43 = U_4*sqrt3;
 +
 
 +
              Arr_prt[j][i].Vx += U_4;
 +
              Arr_prt[j][i].Vy += U_43;
 +
 
 +
              Arr_prt[j-1][ai].Vx -= U_4;
 +
              Arr_prt[j-1][ai].Vy -= U_43;
 +
 
 +
              P[s] += U_1*U_1/8;
 +
            }
 +
 
 +
            ai++; // соседняя частица 2
 +
 
 +
            if (ai < n1)
 +
            {
 +
              Ux = Arr_prt[j-1][ai].Ux - Arr_prt[j][i].Ux;
 +
              Uy = Arr_prt[j-1][ai].Uy - Arr_prt[j][i].Uy;
 +
              U_1 = Uy*sqrt3 - Ux;
 +
              U_4 = U_1 / 4 * dt_sc_m;
 +
              U_43 = U_4*sqrt3;
 +
 
 +
              Arr_prt[j][i].Vx -= U_4;
 +
              Arr_prt[j][i].Vy += U_43;
 +
 
 +
              Arr_prt[j-1][ai].Vx += U_4;
 +
              Arr_prt[j-1][ai].Vy -= U_43;
 +
 
 +
              P[s] += U_1*U_1/8;
 +
            }
 +
        }
 +
 
 +
        if (i > 0) // соседняя частица 3
 +
        {
 +
            U_1 = Arr_prt[j][i-1].Ux - Arr_prt[j][i].Ux;
 +
            Ux = U_1 * dt_sc_m;
 +
 
 +
            Arr_prt[j][i].Vx += Ux;
 +
            Arr_prt[j][i-1].Vx -= Ux;
 +
 
 +
            P[s] += U_1*U_1/2;
 +
        }
 +
      }
 +
 
 +
      K1[s] = 0;
 +
 
 +
      //var Ux, Uy, U_4, U_43, U_1;
 +
      //alert("Ux=" + Ux + "\nUy=" + Uy + "\nU_1=" + U_1);
 +
 
 +
      for (var k = 0; k < n; k++) // вычисление перемещений
 +
      {
 +
        i = k%n1;
 +
        //j = k/n1;
 +
        j = Math.floor(k/n1);
 +
 
 +
        var Vx_loc = Arr_prt[j][i].Vx;
 +
        var Vy_loc = Arr_prt[j][i].Vy;
 +
 
 +
        Arr_prt[j][i].Ux += Vx_loc * dt_sc_m;
 +
        Arr_prt[j][i].Uy += Vy_loc * dt_sc_m;
 +
 
 +
        K1[s] += (Vx_loc*Vx_loc+Vy_loc*Vy_loc)/2;
 +
 
 +
        Vxy_sum += Vx_loc*Vy_loc;
 +
        //str += Vx + "\n";
 +
        //str += Vy;
 +
        Vx_loc *= Vx_loc;
 +
        Vy_loc *= Vy_loc;
 +
        Vx2_sum += Vx_loc*s;
 +
        Vy2_sum += Vy_loc*s;
 +
 
 +
        Vx_loc *= Vx_loc;
 +
        Vy_loc *= Vy_loc;
 +
        Vx4_sum += Vx_loc*s;
 +
        Vy4_sum += Vy_loc*s;
 +
 
 +
    //U1x_sum += Arr_prt[j][i].Ux;
 +
        //U1y_sum += Arr_prt[j][i].Uy;
 +
      }
 +
 
 +
      U1x_sum += Arr_prt[0][0].Ux;
 +
      U1y_sum += Arr_prt[0][0].Uy;
 +
 
 +
      //var str = "P=" + P;
 +
      //alert(str);
 +
      //str = "K=" + K1;
 +
      //alert(str);
 +
  }
 +
 
 +
  var N_graph_Vx = 20;
 +
  var Vx_dens = [];  // массив статистического распределения частиц по компонентам скорости Vx,
 +
  var Vy_dens = [];  // Vy.
 +
  var sVx_dens = [];  // массив статистического распределения частиц по компонентам скорости sqrt(Vx),
 +
  var sVy_dens = [];  // sqrt(Vy).
 +
 
 +
  function ExCalculateReset()
 +
  {
 +
      for (var i = 0; i < N_graph_Vx; i++)
 +
      {
 +
        Vx_dens[i] = 0;
 +
        Vy_dens[i] = 0;
 +
        sVx_dens[i] = 0;
 +
        sVy_dens[i] = 0;
 +
      }
 +
 
 +
      Vx2_av = 0; Vy2_av = 0;
 +
 
 +
      ExCalculate(1); // В начальный момент считаются статистические распределения без запаздывания (k_sen == 1)
 +
  }
 +
 
 +
  function ExCalculate(k_sen) // статистические вычисления на каждом шаге
 +
  {
 +
      var Vx_dens_loc = [];
 +
      var Vy_dens_loc = [];
 +
      var sVx_dens_loc = [];
 +
      var sVy_dens_loc = [];
 +
 
 +
      for (var i = 0; i < N_graph_Vx; i++)
 +
      {
 +
        Vx_dens_loc[i] = 0;
 +
        Vy_dens_loc[i] = 0;
 +
        sVx_dens_loc[i] = 0;
 +
        sVy_dens_loc[i] = 0;
 +
      }
 +
 
 +
      var Vx2_av_loc = 0;
 +
      var Vy2_av_loc = 0;
 +
 
 +
      ///////////////////////////////////////////////////////////////////////
 +
 
 +
      for (var k = 0; k < n; k++)
 +
      {
 +
        i = k%n1;
 +
        j = Math.floor(k/n1);
 +
 
 +
        var Vx_loc = Math.abs(Arr_prt[j][i].Vx);
 +
        var Vy_loc = Math.abs(Arr_prt[j][i].Vy);
 +
        var sVx_loc = Math.sqrt(Vx_loc);
 +
        var sVy_loc = Math.sqrt(Vy_loc);
 +
 
 +
        var n_d = Math.floor(Vx_loc/V_max*(N_graph_Vx-1)+0.5);
 +
        if (n_d < N_graph_Vx) { Vx_dens_loc[n_d]++; }
 +
 
 +
        n_d = Math.floor(Vy_loc/V_max*(N_graph_Vx-1)+0.5);
 +
        if (n_d < N_graph_Vx) { Vy_dens_loc[n_d]++; }
 +
 
 +
        n_d = Math.floor(sVx_loc/sV_max*(N_graph_Vx-1)+0.5);
 +
        if (n_d < N_graph_Vx) { sVx_dens_loc[n_d]++; }
 +
 
 +
        n_d = Math.floor(sVy_loc/sV_max*(N_graph_Vx-1)+0.5);
 +
        if (n_d < N_graph_Vx) { sVy_dens_loc[n_d]++; }
 +
 
 +
        Vx2_av_loc += Vx_loc*Vx_loc;
 +
        Vy2_av_loc += Vy_loc*Vy_loc;
 +
      }
 +
 
 +
      Vx_dens_loc[0] *= 2; Vy_dens_loc[0] *= 2;
 +
      sVx_dens_loc[0] = 0; sVy_dens_loc[0] = 0;
 +
 
 +
      Vx2_av_loc /= n; Vy2_av_loc /= n;
 +
 
 +
      ///////////////////////////////////////////////////////////////////////
 +
      // интегральный регулятор (фильтр низких частот)
 +
 
 +
      for (var i = 0; i < N_graph_Vx; i++)
 +
      {
 +
        Vx_dens[i] = k_sen*Vx_dens_loc[i] + (1-k_sen)*Vx_dens[i];
 +
        Vy_dens[i] = k_sen*Vy_dens_loc[i] + (1-k_sen)*Vy_dens[i];
 +
        sVx_dens[i] = k_sen*sVx_dens_loc[i] + (1-k_sen)*sVx_dens[i];
 +
        sVy_dens[i] = k_sen*sVy_dens_loc[i] + (1-k_sen)*sVy_dens[i];
 +
      }
 +
 
 +
      Vx2_av = k_sen*Vx2_av_loc + (1-k_sen)*Vx2_av;
 +
      Vy2_av = k_sen*Vy2_av_loc + (1-k_sen)*Vy2_av;
 +
  }
 +
 
 +
  function Paint()
 +
  {
 +
      Draw(ctx_X, width_X, height_X, sV_axis ? sVx_dens : Vx_dens, 0);
 +
      Draw(ctx_Y, width_Y, height_Y, sV_axis ? sVy_dens : Vy_dens, 1);
 +
 
 +
      var Vx2_aver = Vx2_sum / s / (s > 1 ? s-1 : 1) * 2 / n;
 +
      var Vy2_aver = Vy2_sum / s / (s > 1 ? s-1 : 1) * 2 / n;
 +
      var Vxy_aver = Vxy_sum / s / (s > 1 ? s-1 : 1) * 2 / n;
 +
 
 +
      span_Vx2.innerHTML = Vx2_aver.toFixed(3);
 +
      span_Vy2.innerHTML = Vy2_aver.toFixed(3);
 +
      span_V2.innerHTML = (Vx2_aver+Vy2_aver).toFixed(3);
 +
      span_Vxy.innerHTML = Vxy_aver.toExponential(2);//toPrecision(3);
 +
      //span_U.innerHTML = "< Ux > = " + (U1x_sum/s).toFixed(2) +
 +
//"________ < Uy > = " + (U1y_sum/s).toFixed(2);
 +
 
 +
      var Vx4_aver = Vx4_sum / s / (s > 1 ? s-1 : 1) * 2 / n;
 +
      var Vy4_aver = Vy4_sum / s / (s > 1 ? s-1 : 1) * 2 / n;
 +
 
 +
      span_Mx.innerHTML = (Vx4_aver/Vx2_aver/Vx2_aver/3).toFixed(3);
 +
      span_My.innerHTML = (Vy4_aver/Vy2_aver/Vy2_aver/3).toFixed(3);
 +
 
 +
      span_k1.innerHTML = ((Vx2_aver+Vy2_aver) / (Vx*Vx+Vy*Vy)).toFixed(3);
 +
      span_k2.innerHTML = ((Vx2_aver-Vy2_aver) / (Vx*Vx-Vy*Vy)).toFixed(3);
 +
      span_1k2.innerHTML = ((Vx*Vx-Vy*Vy) / (Vx2_aver-Vy2_aver)).toFixed(3);
 +
 
 +
      DrawE();
 +
 
 +
      span_E.innerHTML = ((K1[s-1] + P[s-1])/n).toFixed(2);
 +
      span_t.innerHTML = (s*dt_sc_m).toFixed(2);
 +
      span_steps.innerHTML = s;
 +
  }
 +
 
 +
  function Draw(ctx, width, height, V_dens, n_col) // рисование графиков распределения частиц по компонентам скорости Vx, Vy
 +
  {
 +
        ctx.lineWidth="0.6";                    // ширина линии
 +
        ctx.clearRect(0, 0, width, height);    // очистить экран
 +
 
 +
        var dens_V_max;                        // максимальное значение плотности
 +
 
 +
        if (sV_axis)
 +
        {
 +
/*dens_V_max = 1;
 +
for (var i = 0; i < N_graph_Vx; i++)
 +
if (V_dens[i] > dens_V_max) { dens_V_max = V_dens[i]; }*/
 +
 
 +
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);
 +
}
 +
else dens_V_max = n*2*V_max/(N_graph_Vx-1)/Math.sqrt(2*Math.PI*(n_col ? Vy2_av : Vx2_av));
 +
 
 +
        var x_scal = width / (N_graph_Vx-1);    // N_graph_Vx-1 == число промежутков между N_graph_Vx точек
 +
        var y_scal = height / dens_V_max / (sV_axis ? 1.2 : 1.1);  // 1.2,1.1 - коэффициент запаса
 +
 
 +
        var x = 0; var y;
 +
        var n_points = Math.floor(width / 3);
 +
 
 +
        ///////////////////////////////////////////////////////////////////////
 +
        // рисование нормального распределения
 +
 
 +
        if (checkbox_norm.checked)
 +
        {
 +
var width2 = width*width;
 +
 
 +
            if (sV_axis) // распределение по sqrt(V_(x,y))
 +
            {
 +
ctx.strokeStyle = "#006000";
 +
ctx.beginPath();
 +
 
 +
var x1 = -V_max*V_max/width2/width2/(n_col ? Vy2_av : Vx2_av)/2;
 +
var y1 = y_scal*dens_V_max*Math.sqrt(Math.sqrt(2*Math.E/(n_col ? Vy2_av : Vx2_av)))*sV_max/width;
 +
 
 +
ctx.moveTo(x, height);
 +
 
 +
//for (var i = 1; i < n_points; i++)
 +
for (var i = 1; i <= width; i++)
 +
{
 +
//x = 3*i;
 +
x = i;
 +
var x2 = x*x;
 +
 +
y = Math.floor(height - y1*x*Math.exp(x2*x2*x1));
 +
 
 +
  ctx.lineTo(x, y);
 +
}
 +
 
 +
//y = Math.floor(height - y1*width*Math.exp(width2*width2*x1));
 +
//ctx.lineTo(width, y);
 +
 
 +
ctx.stroke();
 +
            }
 +
            else // распределение по V_(x,y)
 +
            {
 +
ctx.strokeStyle = "#006000";
 +
ctx.beginPath();
 +
 
 +
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));
 +
var x1 = -V_max*V_max/width/width/(n_col ? Vy2_av : Vx2_av)/2;
 +
 
 +
y = Math.floor(height - y1);
 +
 
 +
ctx.moveTo(x, y);
 +
 
 +
for (var i = 1; i < n_points; i++)
 +
{
 +
x = 3*i;
 +
y = Math.floor(height - y1*Math.exp(x*x*x1));
 +
 
 +
  ctx.lineTo(x, y);
 +
}
 +
 
 +
y = Math.floor(height - y1*Math.exp(width*width*x1));
 +
ctx.lineTo(width, y);
 +
 
 +
ctx.stroke();
 +
}
 +
}
 +
 
 +
        ///////////////////////////////////////////////////////////////////////
 +
        // рисование вычисленного распределения
 +
 
 +
        ctx.strokeStyle = n_col ? "#ff0000" : "#0000ff";
 +
        ctx.beginPath();
 +
 
 +
        x = 0;
 +
        y = Math.floor(height - y_scal*V_dens[0]);
 +
 
 +
        ctx.moveTo(x, y);
 +
 
 +
        for (var i = 1; i < n_points; i++)
 +
        {
 +
y = 0;
 +
x = 3*i;
 +
 
 +
var j = Math.floor(x/x_scal);
 +
var fi = x/x_scal - j;                      // 0 <= fi < 1
 +
 
 +
if (j >= N_graph_Vx-1) alert("error!");
 +
 
 +
// интерполяция кубическими сплайнами
 +
 
 +
y += V_dens[j] * (fi-1) * (fi-1) * (2*fi+1); // значения
 +
y += V_dens[j+1] * fi * fi * (3-2*fi);      // в узлах
 +
 
 +
var y_d = (j == 0) ? V_dens[1]-V_dens[0] : (V_dens[j+1]-V_dens[j-1])/2;
 +
 
 +
y += y_d * (fi-1) * (fi-1) * fi;      // производная в левом узле
 +
 
 +
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;
 +
 
 +
y += y_d * fi * fi * (fi-1);          // производная в правом узле
 +
 
 +
y = Math.floor(height - y_scal*y);    // линейное отображение в область построения
 +
y = Math.max(0, y);
 +
y = Math.min(y, height);
 +
 
 +
ctx.lineTo(x, y);
 +
        }
 +
 
 +
y = Math.floor(height - y_scal*V_dens[N_graph_Vx-1]);
 +
y = Math.min(y, height);
 +
ctx.lineTo(width, y);
 +
        ctx.stroke();
 +
 
 +
        ///////////////////////////////////////////////////////////////////////
 +
  }
 +
 
 +
  var En_area = 2; // 0 - весь график, 1 - начало, 2 - конец
 +
 
 +
  function DrawE() // рисование графика энергии от времени
 +
  {
 +
// кинетическая:
 +
 
 +
        ctx_E.strokeStyle="#004000";
 +
        ctx_E.lineWidth="0.7";                        // ширина линии
 +
        ctx_E.clearRect(0, 0, width_E, height_E);    // очистить экран
 +
        ctx_E.beginPath();
 +
 
 +
var K_max = K1[0];
 +
var x_scal;
 +
 
 +
x_scal = (En_area == 0) ? x_scal = width_E / Math.max(s, 1500) : width_E / 1500;
 +
 
 +
var y_scal = height_E / K_max;
 +
 
 +
var i0 = (En_area == 2) ? Math.max(0, s-1500) : 0;
 +
 
 +
        var x = 0;
 +
        var y = Math.floor(height_E - K1[i0]*y_scal);
 +
 
 +
        ctx_E.moveTo(x, y);
 +
 
 +
var s_max = (En_area == 1) ? Math.min(s, 1500) : s;
 +
 
 +
        for (var i = i0+1; i < s; i++)
 +
        {
 +
y = Math.floor(height_E - K1[i]*y_scal);
 +
x = Math.ceil((i-i0)*x_scal);
 +
 
 +
ctx_E.lineTo(x, y);
 +
        }
 +
 
 +
        ctx_E.stroke();
 +
 
 +
// средняя линия <E> = K(0)/2
 +
 
 +
        y = Math.floor(height_E - K1[0]*y_scal/2);
 +
 
 +
        ctx_E.strokeStyle="#000000";
 +
        ctx_E.beginPath();
 +
        ctx_E.moveTo(0, y);
 +
ctx_E.lineTo(width_E, y);
 +
        ctx_E.stroke();
 +
  }
 +
 
 +
  //slider_sen.oninput = function()
 +
  slider_sen.onmousemove = function()
 +
  {
 +
      k_sen = span_sen.innerHTML = slider_sen.value;
 +
  };
 +
  number_input_X.oninput = function()
 +
  {
 +
      slider_input_X.value = number_input_X.value;
 +
      Restart();
 +
  };
 +
  slider_input_X.oninput = function()
 +
  {
 +
      number_input_X.value = slider_input_X.value;
 +
  };
 +
  slider_input_X.onmouseup = function() { Restart(); };
 +
  number_input_Y.oninput = function()
 +
  {
 +
      slider_input_Y.value = number_input_Y.value;
 +
      Restart();
 +
  };
 +
  slider_input_Y.oninput = function()
 +
  {
 +
      number_input_Y.value = slider_input_Y.value;
 +
  };
 +
  slider_input_Y.onmouseup = function() { Restart(); };
 +
  reset_calc.onclick = function()
 +
  {
 +
      if (suspended) suspend_calc.onclick();
 +
      Restart();
 +
  };
 +
  suspend_calc.onclick = function()
 +
  {
 +
      suspended = !suspended;
 +
      var str = suspend_calc.value;
 +
      suspend_calc.value = suspend_calc.name;
 +
      suspend_calc.name = str;
 +
  };
 +
  number_input_n1.oninput = function()
 +
  {
 +
      if (number_input_n1.value >= 10)
 +
      {
 +
slider_input_n1.value = number_input_n1.value;
 +
span_n1.innerHTML = " x " + number_input_n1.value;
 +
n2 = n1 = number_input_n1.value;
 +
n = n1*n2;
 +
 
 +
span_n.innerHTML = n;
 +
Restart();
 +
  }
 +
  };
 +
  slider_input_n1.oninput = function()
 +
  {
 +
  number_input_n1.value = slider_input_n1.value;
 +
 
 +
      if (slider_input_n1.value >= 10)
 +
      {
 +
span_n1.innerHTML = " x " + number_input_n1.value;
 +
span_n.innerHTML = number_input_n1.value*number_input_n1.value;
 +
  }
 +
  };
 +
  slider_input_n1.onmouseup = function()
 +
  {
 +
  number_input_n1.value = slider_input_n1.value;
 +
 
 +
      if (slider_input_n1.value >= 10)
 +
      {
 +
span_n1.innerHTML = " x " + number_input_n1.value;
 +
n2 = n1 = number_input_n1.value;
 +
n = n1*n2;
 +
 
 +
span_n.innerHTML = n;
 +
Restart();
 +
  }
 +
  };
 +
  radio_V.onchange = function() { sV_axis = 0; span_sqrt1.innerHTML = span_sqrt2.innerHTML = ""; Paint(); };
 +
  radio_sV.onchange = function() { sV_axis = 1; span_sqrt1.innerHTML = span_sqrt2.innerHTML = "sqrt"; Paint(); };
 +
  radio_CV.onchange = function() { norm = 0; Restart(); };
 +
  radio_NV.onchange = function() { norm = 1; Restart(); };
 +
  checkbox_norm.onclick = function() { Paint(); };
 +
  radio_En_all.onchange = function() { En_area = 0; Paint(); };
 +
  radio_En_begin.onchange = function() { En_area = 1; Paint(); };
 +
  radio_En_end.onchange = function() { En_area = 2; Paint(); };
 +
 
 +
  Restart();
 +
  setInterval(Step, 1000 / 30);              // функция step будет запускаться 30 раз в секунду (в 1000 мс)
 +
}
 +
</syntaxhighlight>
 +
Файл '''"TriLatLin.html"'''
 +
<syntaxhighlight lang="html5" line start="1" enclose="div">
 +
<!DOCTYPE html>
 +
<html>
 +
<head>
 +
    <title>Треугольная Решетка</title>
 +
    <script src="TriLatLin.js"></script>
 +
    <!link rel="stylesheet" type="text/css" href="js_tm_styles.css" />
 +
</head>
 +
<body onload="MainTriLatticeTemper();">
 +
    <p>Количество частиц:
 +
        <input type="range" id="slider_input_n1"
 +
        min=10 max=300 value=30 step=1 style="width: 160px;">
 +
        <span id="span_n">900</span> (<input type="number"
 +
        id="number_input_n1" min=10 max=300 value=30 step=1 style="width: 50px;">
 +
        <span id="span_n1"> x 30</span> рядов).
 +
    </p>
 +
 
 +
    <p>Начальные перемещения частиц – нулевые.</p>
 +
    <p>Начальное распределение вектора скорости частиц – случайное, с плотностью:</p>
 +
 
 +
    <p><input type="radio" id="radio_CV" name="dens" checked />
 +
    Равномерная плотность внутри эллипса <I><B>V<SUB>x</SUB></B></I><SUP>2</SUP> /
 +
    <I><B>V<SUB>x,max</SUB></B></I><SUP>2</SUP> + <I><B>V<SUB>y</SUB></B></I><SUP>2</SUP> /
 +
    <I><B>V<SUB>y,max</SUB></B></I><SUP>2</SUP> = 1; 0 вне эллипса,<br>
 +
    <input type="radio" id="radio_NV" name="dens" />
 +
    Нормальное распределение плотности.</p>
 +
 
 +
    <p>Задаваемые начальные среднеквадратические значения &sigma; (<I><B>V<SUB>x</SUB></B></I>(0)) и
 +
    &sigma; (<I><B>V<SUB>y</SUB></B></I>(0)) указаны под графиками.</p>
 +
 
 +
    <p><B>Распределение частиц по компонентам скорости <I>V<SUB>x</SUB></I> (слева)
 +
    и <I>V<SUB>y</SUB></I> (справа).</B></p>
 +
 
 +
    <p><input type="radio" id="radio_V" name="axis" checked />
 +
    Оси абсцисс – |<I><B>V<SUB>x</SUB></B></I>| и |<I><B>V<SUB>y</SUB></B></I>|
 +
    (масштаб одинаковый).<br>
 +
    <input type="radio" id="radio_sV" name="axis" />
 +
    Оси абсцисс – sqrt|<I><B>V<SUB>x</SUB></B></I>| и sqrt|<I><B>V<SUB>y</SUB></B></I>|
 +
    (масштаб одинаковый).</p>
 +
 
 +
    <p>Оси ординат – плотности распределения частиц.</p>
 +
    <p><input type=checkbox id=checkbox_norm checked />Изобразить нормальное распределение с дисперсией,
 +
    равной дисперсии вычисляемой плотности.</p>
 +
 
 +
    <table>
 +
        <tr><td><I>P</I></td>
 +
            <td><canvas id="canvas_densitas_Vx" width="300" height="200" style="border:
 +
                1px solid #000000"></canvas></td>
 +
            <td><canvas id="canvas_densitas_Vy" width="300" height="200" style="border:
 +
                1px solid #000000"></canvas></td>
 +
            <td><input type="range" orient="vertical" id="slider_sen" min=0.1 max=1 value=0.1 step=0.1
 +
                style="height: 160px; width: 30px; -webkit-appearance: slider-vertical;" /></td>
 +
            <td>Чувствительность<br> к мгновенным изменениям<br><span id="span_sen"></span></td>
 +
        </tr>
 +
        <tr><td></td><td style="text-align: center"><span id = "span_sqrt1"></span>|<I><B>V<SUB>x</SUB></B></I>|</td>
 +
        <td style="text-align: center"><span id = "span_sqrt2"></span>|<I><B>V<SUB>y</SUB></B></I>|</td>
 +
        </tr>
 +
        <tr><td></td><td></td><td></td></tr>
 +
        <tr><td></td><td></td><td></td></tr>
 +
        <tr><td></td><td></td><td></td></tr>
 +
        <tr><td></td>
 +
            <td><input type="range" id="slider_input_X" min=0 max=10 value=2 step=0.1
 +
                style="width: 160px;" />&sigma; (<I><B>V<SUB>x</SUB></B></I>(0)) =<input type="number"
 +
                id="number_input_X" min=0 max=10 value=2 step=0.1 style="width: 50px;" /></td>
 +
            <td><input type="range" id="slider_input_Y" min=0 max=10 value=2 step=0.1
 +
                style="width: 160px;" />&sigma; (<I><B>V<SUB>y</SUB></B></I>(0)) =<input type="number"
 +
                id="number_input_Y" min=0 max=10 value=2 step=0.1 style="width: 50px;" /></td>
 +
        </tr>
 +
    </table>
 +
 
 +
    <br>
 +
    <input type="button" id="reset_calc" value="Старт">
 +
    <input type="button" id="suspend_calc" value="Приостановить" name = "Возобновить">
 +
    <br>
 +
 
 +
    <p>Средние значения <I><B>V<SUB>x</SUB></B></I><SUP>2</SUP> и
 +
    <I><B>V<SUB>y</SUB></B></I><SUP>2</SUP> по всем частицам.<br>
 +
    (Усреднение производится также по времени с весом, пропорциональным времени):</p>
 +
 
 +
    <I><B>T<SUB>xx</SUB></B><SUP>S</SUP></I> =
 +
    < <I><B>V<SUB>x</SUB></B></I><SUP>2</SUP> > = <span id="span_Vx2"></span>
 +
    <br>
 +
    <I><B>T<SUB>yy</SUB></B><SUP>S</SUP></I> =
 +
    < <I><B>V<SUB>y</SUB></B></I><SUP>2</SUP> > = <span id="span_Vy2"></span>
 +
    <br>
 +
    < <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>
 +
    <br>
 +
    < <I><B>V<SUB>x</SUB>V<SUB>y</SUB></B></I> > = <span id="span_Vxy"></span>
 +
    <br>
 +
 
 +
    <p>Отношение моментов распределения компонент скорости:<br>
 +
    Для нормального распределения
 +
    < <I><B>V</B></I><SUP>4</SUP> >  / < <I><B>V</B></I><SUP>2</SUP> ><SUP>2</SUP> / 3 = 1</p>
 +
    < <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 =
 +
    <span id="span_Mx"></span><br>
 +
    < <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 =
 +
    <span id="span_My"></span><br>
 +
 
 +
    <p>Отношение стационарных и начальных квадратов компонент скорости:</p>
 +
    <I><B>T<SUB>xx</SUB></B><SUP>S</SUP></I> + <I><B>T<SUB>yy</SUB></B><SUP>S</SUP></I> =
 +
    <I>k</I><SUB>1</SUB>
 +
    (<B><I>T<SUB>xx</SUB></I></B><SUP>0</SUP> + <B><I>T<SUB>yy</SUB></I></B><SUP>0</SUP>)
 +
    <br>
 +
    <I><B>T<SUB>xx</SUB></B><SUP>S</SUP></I> – <I><B>T<SUB>yy</SUB></B><SUP>S</SUP></I> =
 +
    <I>k</I><SUB>2</SUB>
 +
    (<B><I>T<SUB>xx</SUB></I></B><SUP>0</SUP> – <B><I>T<SUB>yy</SUB></I></B><SUP>0</SUP>)
 +
    <br>
 +
 
 +
    <I>k</I><SUB>1</SUB> = <span id="span_k1"></span><br>
 +
    <I>k</I><SUB>2</SUB> = <span id="span_k2"></span><br>
 +
    (1/<I>k</I><SUB>2</SUB> = <span id="span_1k2"></span>)
 +
 
 +
    <!span id="span_U">  <!/span>    <!br>
 +
    <p><B>Изменение кинетической энергии во времени.</B> Горизонтальная линия – половина полной энергии.</p>
 +
    <canvas id="canvas_energy" width="1000" height="300" style="border: 1px solid #000000"></canvas>
 +
    <br>
 +
    <input type="radio" id="radio_En_all" name="radio_En" />График целиком.
 +
    <input type="radio" id="radio_En_begin" name="radio_En" />Начало графика.
 +
    <input type="radio" id="radio_En_end" name="radio_En" checked />Окончание графика.
 +
 
 +
    <p>Полная энергия, приходящаяся на одну частицу: <I>E</I> = <span id="span_E">  </span>.
 +
    <br>
 +
    Время <I>t</I> = <span id="span_t">  </span> (<span id="span_steps"></span> шагов)</p>
 +
</body>
 +
</html>
 +
</syntaxhighlight>
 +
</div>
 +
</div>
  
 
[[Category: Виртуальная лаборатория]]
 
[[Category: Виртуальная лаборатория]]
 
[[Category: Программирование]]
 
[[Category: Программирование]]
 
[[Category: JavaScript]]
 
[[Category: JavaScript]]

Версия 19:48, 17 декабря 2015

Виртуальная лаборатория > Статистические распределения в двумерном кристалле с треугольной решеткой

Рассматривается система частиц моделируемых материальными точками с линейным законом взаимодействия в плоскости. Частицы располагаются в треугольной решетке, края свободны. Все частицы и связи одинаковые. Уравнение движения для каждой частицы имеет вид:

[math] m \ddot{\underline u} = c \sum_{\alpha}{\underline{e}_{\alpha} \underline{e}_{\alpha} \cdot (\underline{u}_{\alpha} - \underline u)}, [/math]

где [math]m[/math] – масса частицы, с – жесткость связи, [math]\underline{u}[/math] – вектор перемещения, [math]\underline{e}_{\alpha}[/math] – единичный вектор, направленный к одной из соседних частиц с индексом [math]\alpha[/math]:

[math] \underline{e}_{\alpha} = (\underline{r}_{\alpha} - \underline{r}) / |\underline{r}_{\alpha} - \underline{r}|, [/math]

где [math]\underline{r}[/math] – радиус-вектор частицы в начальной конфигурации.

Ось [math]x[/math] направлена вдоль одного из направлений связей. [math]m = 1,\quad c = 1[/math], шаг интегрирования [math]dt = 0.005[/math].

Скачать программу: 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>Задаваемые начальные среднеквадратические значения &sigma; (<I><B>V<SUB>x</SUB></B></I>(0)) и
 28     &sigma; (<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;" />&sigma; (<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;" />&sigma; (<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>