import java.text.DecimalFormat;

import java.util.*;

import java.text.DecimalFormat;

public class zdan1 {

static double fp=0.11;

static double dElemMax=9.5;

static double vMin=10;

public static void main(String[] args) { //14.05.2012 ()

DecimalFormat pip = new DecimalFormat("#.0");

// Характеристикирасчетнойобласти (размеры и номера)

// точка (i,j) относится к центруячейки

// intNx=13, Nx1=5, Nx2=7, Ny=22, Ny1=3;

int Nx=20, Nx1=8, Nx2=11, Ny=20, Ny1=4; // характеристикирасчетнойобласти

int door_0_X=5, door_1_X=16, door_2_Y=5; // положениедверей

int n_Out = 2; // количествовыходов

int coorOut[][] = new int[n_Out][2]; // координаты i,j выхода k

coorOut[0][0]=1; coorOut[0][1]=1; // координаты i,j ячейки с выходом 0

coorOut[1][0]=Nx-2; coorOut[1][1]=1; // координаты i,j ячейки с выходом 1

// coorOut[1][0]=Nx1; coorOut[1][1]=Ny-2; // координаты i,j ячейки с выходом 1

int direcOut[] = new int import java.text.DecimalFormat;[n_Out]; // Направлениевыхода: +-1 (х); +-2(у); +-3(z)

direcOut[0]=-1; direcOut[1]=1;

double outL[]= {1.0, 1.0}; // ширинавыхода в ячейке k=0 1, ... , м

double peopleOut[] = new double[n_Out]; // количестволюдейвышедшихчерездверь

// межкомнатныестенысовпадают с однимизкоординатныхнаправлений (нетуглов)

int n_Door = 3; // количествомежкомнатныхдверей

int direcDoor[] = new int[n_Door]; // Направлениечерезпроем: 1 (х); 2(у); 3(z)

direcDoor[0]=1; direcDoor[1]=1; direcDoor[2]=2;

double doorL[]= {1.0, 1.0, 1.0}; // ширинадвери в ячейке k=0 1, ... , м

int coorDoor[][] = new int[n_Door][2]; // координаты i,j дверей k

coorDoor[0][0]=door_0_X; coorDoor[0][1]=2; // координаты i,j ячейки с дверью 0

coorDoor[1][0]=door_1_X; coorDoor[1][1]=2; // координаты i,j ячейки с дверью 1

coorDoor[2][0]=9; coorDoor[2][1]=door_2_Y; // координаты i,j ячейки с дверью 2

int n_in = 2; // количествовходов (Источники)

int coorIn[][] = new int[n_in][2]; // координаты i,j import java.text.DecimalFormat; Источника k

coorIn[0][0]=Nx1; coorIn[0][1]=Ny-2; // координатыячейки с входом 0+1

coorIn[1][0]=Nx2; coorIn[1][1]=Ny-2; // координатыячейки с входом 1+1

double powerIn[]= {15.0, 25.0}; // мощностьвхода, человек/(мин*м2)

// Задатькоординатыячеек с лестницами ( Покапредполагается ,что tipe_elem = 0 или tipe_elem = 2,5 - проем

// type_elem = 0 - горизонтальныйпуть в здании type_elem = 1 - гор. путьвне здания

// type_elem = 2 - дверной проем в расчетной области

// type_elem = 3 - лестница вниз type_elem = 4 - - лестница вверх

// type_elem = 5 - выход из расчетной области (например, из здания)

/* Двери относятся к одной ячейке */

int nn= 100; // Количество людей

double people=0, num_people=0, peopleTotal=0;

double Lx=10; // размер по Х, м

double Ly=10; // размер по Y, м

double hx=Lx/(Nx-1), hy=Ly/(Ny-1); // Шаги расчетной сетки, м

double elemS import java.text.DecimalFormat; = hx*hy; // площадь элемента, м*м

/* DecimalFormat pr = new DecimalFormat("#0.00");

System.out.println("initial number of people "+nn +"\n"+

"hx "+pr.format(hx)+ " hy " + pr.format(hy)

+" area of cell "+pr.format(hx*hy) +"\n"+

"number of cell "+number+"\n"+

"area of the computational domain "+pr.format(hx*hy*number)+"\n"+

"initial flux density "+ pr.format(d0) );



*/

int array[][] = new int[Nx][Ny];

int out=-1, in=+1;// область окаймлена ячейками с -1, что означает, что ячейка вне области расчета.

// инициализация массива out -вне области расчета

// in - в области расчета

for (int i=0;i

for(int j=0;j

for (int i import java.text.DecimalFormat;=1;i

for(int j=1;j

for (int i=Nx1;i<=Nx2;i++)

for(int j=1;j

for (int k=0; k

switch(direcDoor[k]){

case 1: int kki=coorDoor[k][0], kkj=coorDoor[k][1] ;

for(int j=1;j

case 2: int kkjj=coorDoor[k][1], kkii=coorDoor[k][0] ;

for(int i=1;i

default: { System.out.println(" !59! Mistake direcDoor[k] "+direcDoor[k]);}; } // ошибка

}

/* System.out.println("initial state ");

for(int i=0; i

*/ // Переопределение массива = задание номера ячейки в области расчета

int number=0;

for (int i=0;i

for (int j=0;j

else {array[i][j]=number; number++; } ;

/* System.out.println("number of elements ");

for(int i=0; i

*/

double d0=nn/(hx*hy*number); // начальная плотность людей

//Формирование списка ячеек

int number_elem; // номер элемента

int type_elem; // тип ячейки по наклону

// type_elem = 0 - горизонтальный путь в здании type_elem = 1 - гор. путь вне здания

// type_elem = 2 - дверной проем в расчетной области

// type_elem = 3 - лестница вниз type_elem = 4 - - лестница вверх

// type_elem import java.text.DecimalFormat; = 5 - выход из расчетной области (например, из здания)

int xreduction; // номер левый (уменьшение по х)

int xincrease; // номер правый (увеличение по х)

int yreduction; // номер нижний (уменьшение по у)

int yincrease; // номер верхний (увеличение по у)

double powerSourse; // мощность источника в ячейке, человек/минуту

int outelem; // признак выхода - связь с выходом k.

// при outelem=-1, т.е. <0 - номер выхода пока не определен

int direct_elem; // направление прохода по ячейке: 1 по х; 2 по у; 3 по z (0 - е определено)

double time_outelem;// время достижения выхода k из элемента numder, минут

double hxyz;

int number_Door; // номер двери 0,1,2... в расчетной области (включая двери для выхода import java.text.DecimalFormat; из расчетной обл.)

// Определение максимальной плотности потока dmax, чел/м2

// (Вычисляется для каждого элемента, но уточняется для элементов с наличием дверей

elem elemdd =new elem(100,0, 0,0,0,0,0,0);

double vElem, dvElem, dMax, ffElem, ffElemOld, ffMin, ddd, ddp=0.005;

double qmax[]={16.5, 16.5, 19.6, 16.0, 11.0, 19.6}; // максимальный поток, м/мин

double dmax[] = new double [7];

int priz=0;

for (int el=0; el

{ ffMin=1.0e+5; dMax=0; ffElemOld=0;

ddd=zdan1.dElemMax*0.99;

do

{ elemdd.d_elem = ddd=ddd-ddp/elemS;

if ( (el == 2) | (el == 5) ) { elemdd.type_elem = 2; vElem=elemdd.velem(1.0);

if (ddd >= 9) dvElem=10*(3.75+2.5*1); else dvElem= ddd*vElem;}

else { elemdd.type_elem = 0; vElem=elemdd.velem(); dvElem= ddd*vElem;}

ffElem = dvElem - qmax[el]/(zdan1.fp) ;

if (ffElem*ffElemOld import java.text.DecimalFormat; < 0) { priz=0; dMax=ddd; ffMin= ffElem; break; }; ffElemOld=ffElem;

if (Math.abs(ffMin) > (Math.abs(ffElem))) {priz=100; ffMin=ffElem; dMax=ddd; } }

while (ddd > 0.5);

dmax[el]=dMax;

System.out.println(" el= "+pip.format(el)+" priz= "+priz+" ffMin= "+pip.format(ffMin)+ " Dmax= "+ pip.format(dMax));

} // System.out.println(Arrays.toString(dmax));

ArrayList al = new ArrayList(); // базовый список ячеек

ArrayList al_Door = new ArrayList(); // базовый список дверей

ArrayList elemOut = new ArrayList();// Списки на выход (n_out);

for (int ii = 0; ii < n_Out; ii++) elemOut.add(new ArrayList());

int k_out[]= new int[n_Out]; // номер обрабатываемой ячейки списка выхода

int finis_out[]= new int[n_Out]; // номер последней ячейки списка import java.text.DecimalFormat; выхода

int k_Door = 0; // номер двери

for (int i=1; i

for (int j=1; j

if (array[i][j]<0) continue;

else{ number_elem=array[i][j];

powerSourse = 0;

type_elem=0; // type_elem = 0 - горизонтальный путь в здании

outelem = -1; // при outelem=-1, т.е. <0 - номер выхода пока не определен

direct_elem=0; // направление не определено

if (array[i-1][j]>=0) xreduction=array[i-1][j]; else xreduction=out;

if (array[i+1][j]>=0) xincrease =array[i+1][j]; else xincrease =out;

if (array[i][j-1]>=0) yreduction=array[i][j-1]; else yreduction=out;

if (array[i][j+1]>=0) yincrease =array[i][j+1]; else yincrease =out;

elem elem1 =new elem(number_elem,type import java.text.DecimalFormat;_elem,

xreduction,xincrease,yreduction,yincrease,

powerSourse,outelem);

elem1.d_elem = d0; // начальное распределение плотности людей

elem1.d_max = dmax[type_elem]; // максимальная плотнеость

elem1.number_Door = -1; // номер двери не определен

for (int k=0; k

{ if ((i == coorOut[k][0]) & (j == coorOut[k][1])){elem1.outelem = k; peopleOut[k]=0;

switch(direcOut[k]){

case -1: hxyz=0.5*hx; direct_elem=-1; break;

case 1: hxyz=0.5*hx; direct_elem=1; break;

case -2: hxyz=0.5*hy; direct_elem=-2; break;

case 2: hxyz=0.5*hy; direct_elem=2; break;

// case -3: case 3: hxyz= hxyz=0.5*hz; direct_elem=3; break;

default: {hxyz=-1000; direct_elem=-1000;}; } // ошибка

elem1.type_elem = 5;

elem1.d_max = dmax[type_elem]; // максимальная плотнеость

elem import java.text.DecimalFormat;1.time_outelem=hxyz/elem1.velem(outL[k]);

elem1.direct_elem = direct_elem;

elem1.number_Door = k_Door; k_Door++; // номер двери

k_out[k]= 0; // номер обрабатываемой ячейки списка выхода

finis_out[k]= 0; // номер последней ячейки списка выхода

doorElem doorOut =

new doorElem(elem1.number,elem1.type_elem,elem1.direct_elem,outL[k]);

elem1.d_max = doorOut.dmax(outL[k],hx,hy);

elemOut.get(k).add(elem1);

al_Door.add(doorOut); doorOut.printdoor();

System.out.println("number out "+number_elem+" elem1.d_max(type=5) "+elem1.d_max);

// System.out.println("number out "+number_elem+" outelem "+elem1.outelem);

// elem1.printelem();

} };

for (int k=0; k

if ((i == coorDoor[k][0]) & (j == coorDoor[k][1])){

elem1.type_elem = 2;

elem1.number_Door = k_Door; // номер двери

doorElem doorxx =

new doorElem(elem1.number,elem1.type_elem,elem1.direct_elem, doorL[k]);

elem1.d_max = doorxx.dmax(doorL[k],hx,hy);

k_Door++;

System.out.println("number out "+number_elem+" elem1.d_max(type=2) "+elem1.d_max);

al_Door.add(doorxx); doorxx.printdoor();

} };

for (int k=0; k

if ((i == coorIn[k][0]) && (j == coorIn[k][1]))

{ elem1.powerSourse = powerIn[k];

System.out.println("number in "+elem1.number +" powerSourse "+

elem1.powerSourse); } };

al.add(elem1);}

// Формирование import java.text.DecimalFormat; списков элементов для каждого выхода k=0,.... n_out

int klist, // число проходов по списку ячеек

k, // номер элемента в списке текущего выхода

k_near, // номера соседних элементов по отношению к элементу k

k_kd; // предписание выхода для ячеек k_xred, k_xinc, k_yred, k_yinc

double time_kk, // время достижения элемента от выхода = kk

time_kd, // время достижения элемента от выхода != kk

time_elem; // время прохождения ячейки

elem elemxx; // обрабатываемый элемент

elem elemk_near; // сосед обрабатываемого элемента

boolean elem_cen, bout [] = new boolean[n_Out];

int indeks[]= new int[5];

double d_indeks[] = new double[5];

double nk0, nk_near, ntran ;

double d_tranzit, qout, qin, qmax_xx;

double elemL;

int num import java.text.DecimalFormat;;

int ntime=1; // число проходов по времени до корректировки списков выхода [в режиме отладки цикл печати]

double kust=0.9; // устойчивость расчета при kust -> 0 ( kust<1 )

double time=0, tay= (Math.min(hx,hy)/100.0)*kust; // минут

boolean bb;

for (int kk=0; kk

/* main do

do {*/

for (int kkkk=0; kkkk<2; kkkk++)

{

klist=0; elem_cen = true;

do // Формирование списков от каждого выхода

{ klist++; // число проходов по списку выходов

for(int kk=0; kk

{ bout[kk]=false;

if ( elemOut.get(kk).isEmpty() )

{System.out.println("\n !230! elemOut.get(kk).isEmpty"); continue; } // пустая очередь на выход kk

k=k_out[kk]; // обраб. элемент в очереди на выход kk

if import java.text.DecimalFormat; (k<0) System.out.println("\n !232! k=k_out[kk] <0 "+k);

elemxx =elemOut.get(kk).get(k);

// System.out.println("\n kk= "+kk+ " k_out[kk]= "+k); elemxx.printelem();

//**********

// Определение последовательности формирования списков выхода по условию мак. плотности

for(int kdirect=0; kdirect<5; kdirect++) { indeks[kdirect]=0; d_indeks[kdirect]=0; }

if ((k_near=elemxx.xreduction) >=0) // сосед слева в расчетной области (номер ячейки) Индекс 1

{ elemk_near = al.get(k_near); // ячейка соседа слева

k_kd = elemk_near.outelem; // предписание выхода для соседа слева

if (k_kd != kk) // сосед слева подлежит обработке

{ d_indeks[1]=elemk_near.d_elem; } };

if ((k_near=elemxx.xincrease) >=0) // сосед справа в расчетной области (номер ячейки import java.text.DecimalFormat;) Индекс 2

{ elemk_near = al.get(k_near); // ячейка соседа справа

k_kd = elemk_near.outelem; // предписание выхода для соседа справа

if (k_kd != kk) // сосед подлежит обработке

{ d_indeks[2]=elemk_near.d_elem; } };

if ((k_near=elemxx.yreduction) >=0) // сосед снизу в расчетной области (номер ячейки) Индекс 3

{ elemk_near = al.get(k_near); // ячейка соседа снизу

k_kd = elemk_near.outelem; // предписание выхода для соседа справа

if (k_kd != kk) // сосед подлежит обработке

{ d_indeks[3]=elemk_near.d_elem; } };

if ((k_near=elemxx.yincrease) >=0) // сосед сверху в расчетной области (номер ячейки) Индекс 4

{ elemk_near = al.get(k_near); // ячейка соседа сверху

k_kd = elemk_near.outelem; // предписание import java.text.DecimalFormat; выхода для соседа справа

if (k_kd != kk) // сосед подлежит обработке

{ d_indeks[4]=elemk_near.d_elem; } };

//************

// Обработка соседей ячейки elemxx =elemOut.get(kk).get(k) выходной очереди на выход kk

if ((k_near=elemxx.xreduction) >=0) // сосед слева в расчетной области (номер ячейки)

{ elemk_near = al.get(k_near); // ячейка соседа слева

k_kd = elemk_near.outelem; // предписание выхода для соседа слева

if (k_kd != kk) // сосед слева подлежит обработке

{ if ( k_kd < 0) // не приписан к выходу (обрабатываем ячейку и приписываем к выходу)

{ al.get(k_near).outelem = kk; // приписали к выходу kk

al.get(k_near).direct_elem = 1; // x

al.get(k_near).time_outelem = elemxx.time_outelem import java.text.DecimalFormat; + hx/elemk_near.velem();

elemOut.get(kk).add(al.get(k_near));

finis_out[kk]=finis_out[kk]+1;

//System.out.println("\n k_red = "+k_near+" finis_out[kk] = "+finis_out[kk]);

// al.get(k_near).printelem();

}

else // обработка случая когда сосед слева приписан к выходу != kk

{ time_kd=elemk_near.time_outelem; // время достижения элемента k_xred от выхода != kk

if (time_kd <= 0) {System.out.println("\n !!! time_kd= "+time_kd); elemk_near.printelem();}

time_elem = hx/elemk_near.velem();

time_kk = elemxx.time_outelem + time_elem; // время достижения элемента k_xred от выхода = kk

// если время достижения import java.text.DecimalFormat; выхода kk значительно меньше чем k_kd ( != kk ),

if ((time_kk+time_elem) <= time_kd) // то выход для ряда ячеек переопределяется

{ al.get(k_near).outelem = kk; // приписали к выходу kk

al.get(k_near).direct_elem = 1; // x

al.get(k_near).time_outelem = elemxx.time_outelem + hx/elemk_near.velem();

elemOut.get(kk).add(al.get(k_near));

finis_out[kk]=finis_out[kk]+1;

System.out.println("\n k_incr_x = "+k_near+" finis_out[kk] = "+finis_out[kk]);

// al.get(k_near).printelem();

int k_element = elemOut.get(k_kd).indexOf(elemk_near); // Элементы удалить c k_element

if (k_element import java.text.DecimalFormat; <0 ) { System.out.println(" !220! k_element "+k_element); al.get(k_near).printelem();}

List listOut_kd = elemOut.get(k_kd); // начало сжатия списка выхода k_kd

ListIterator itrOut_kd = listOut_kd.listIterator(k_element);

while (itrOut_kd.hasNext()) // переопределение списка выхода k_kd

{ elem element =(elem) itrOut_kd.next(); // следующий элемент списка выхода k_kd

int number_al = element.number;

if (number_al <0 ) { System.out.println(" !226! number_al "+number_al); }

al.get(number_al).outelem = -1; // отписка от выхода kk

al.get(number_al).direct_elem = 0;

al.get(number_al).time_outelem = 0; };

while ((k_element) < listOut_kd.size()) {listOut_kd.remove(k_element);}

finis_out[k_kd]=listOut import java.text.DecimalFormat;_kd.size();

if (k_out[k_kd]>=k_element) k_out[k_kd]=k_element-1;

if ((k_element-1) <0 ) { System.out.println(" !233! k_element "+k_element); } }

} }

} // конец обработки соседа слева

if ((k_near=elemxx.xincrease) >=0) // сосед справа в расчетной области (номер ячейки)

{ elemk_near = al.get(k_near); // ячейка соседа справа

k_kd = elemk_near.outelem; // предписание выхода для соседа справа

if (k_kd != kk) // сосед подлежит обработке

{ if ( k_kd < 0) // не приписан к выходу (обрабатываем ячейку и приписываем к выходу)

{ al.get(k_near).outelem = kk; // приписали к выходу kk

al.get(k_near).direct_elem = -1; // x

al.get(k_near).time_outelem = elemxx import java.text.DecimalFormat;.time_outelem + hx/elemk_near.velem();

elemOut.get(kk).add(al.get(k_near));

finis_out[kk]=finis_out[kk]+1;

//System.out.println("\n k_inc = "+k_near+" finis_out[kk] = "+finis_out[kk]);

//al.get(k_near).printelem();

}

else // обработка случая когда сосед слева приписан к выходу != kk

{ time_kd=elemk_near.time_outelem; // время достижения элемента k_inc от выхода != kk

if (time_kd <= 0) {System.out.println("\n !251! time_kd= "+time_kd); elemk_near.printelem();}

time_elem = hx/elemk_near.velem();

time_kk = elemxx.time_outelem + time_elem; // время достижения элемента k_near от выхода = kk

// если время import java.text.DecimalFormat; достижения выхода kk значительно меньше чем k_kd ( != kk ),

if ((time_kk+time_elem) <= time_kd) // то выход для ряда ячеек переопределяется

{ al.get(k_near).outelem = kk; // приписали к выходу kk

al.get(k_near).direct_elem = -1; // x

al.get(k_near).time_outelem = elemxx.time_outelem + hx/elemk_near.velem();

elemOut.get(kk).add(al.get(k_near));

finis_out[kk]=finis_out[kk]+1;

System.out.println("\n k_xinc = "+k_near+" finis_out[kk] = "+finis_out[kk]);

// al.get(k_near).printelem();

int k_element = elemOut.get(k_kd).indexOf(elemk_near); // Элементы удалить c k_element

if (k_element import java.text.DecimalFormat; <0 ) { System.out.println(" !264! k_element "+k_element); al.get(k_near).printelem();}

List listOut_kd = elemOut.get(k_kd); // начало сжатия списка выхода k_kd

ListIterator itrOut_kd = listOut_kd.listIterator(k_element);

while (itrOut_kd.hasNext()) // переопределение списка выхода k_kd

{ elem element =(elem) itrOut_kd.next(); // следующий элемент списка выхода k_kd

int number_al = element.number;

if (number_al <0 ) { System.out.println(" !!! number_al "+number_al); }

al.get(number_al).outelem = -1; // отписка от выхода kk

al.get(number_al).direct_elem = 0;

al.get(number_al).time_outelem = 0; };

while ((k_element) < listOut_kd.size()) {listOut_kd.remove(k_element);}// nn_kd import java.text.DecimalFormat;++;}

finis_out[k_kd]=listOut_kd.size();

if (k_out[k_kd]>=k_element) k_out[k_kd]=k_element-1;

if ((k_element-1) <0 ) { System.out.println(" !!! k_element "+k_element); } }

} }

} // конец обработки соседа справа

if ((k_near=elemxx.yreduction) >=0) // сосед снизу в расчетной области (номер ячейки)

{ elemk_near = al.get(k_near); // ячейка соседа снизу

k_kd = elemk_near.outelem; // предписание выхода для соседа снизу

if (k_kd != kk) // сосед снизу подлежит обработке

{ if ( k_kd < 0) // не приписан к выходу (обрабатываем ячейку и приписываем к выходу)

{ al.get(k_near).outelem = kk; // приписали к выходу kk

al.get(k_near).direct_elem = 2; // x

al.get(k import java.text.DecimalFormat;_near).time_outelem = elemxx.time_outelem + hy/elemk_near.velem();

elemOut.get(kk).add(al.get(k_near));

finis_out[kk]=finis_out[kk]+1;

// System.out.println("\n k_yred = "+k_near+" finis_out[kk] = "+finis_out[kk]);

// al.get(k_near).printelem();

}

else // обработка случая когда сосед снизу приписан к выходу != kk

{ time_kd=elemk_near.time_outelem; // время достижения элемента k_xred от выхода != kk

if (time_kd <= 0) {System.out.println("\n !!! time_kdy= "+time_kd); elemk_near.printelem();}

time_elem = hy/elemk_near.velem();

time_kk = elemxx.time_outelem + time_elem; // время достижения элемента k_xred от выхода import java.text.DecimalFormat; = kk

// если время достижения выхода kk значительно меньше чем k_kd ( != kk ),

if ((time_kk+time_elem) <= time_kd) // то выход для ряда ячеек переопределяется

{ al.get(k_near).outelem = kk; // приписали к выходу kk

al.get(k_near).direct_elem = 2; // y

al.get(k_near).time_outelem = elemxx.time_outelem + hy/elemk_near.velem();

elemOut.get(kk).add(al.get(k_near));

finis_out[kk]=finis_out[kk]+1;

//System.out.println("\n k_incr_y = "+k_near+" finis_out[kk] = "+finis_out[kk]);

//al.get(k_near).printelem();

int k_element = elemOut.get(k_kd).indexOf(elemk_near); // Элементы удалить c k_element

if import java.text.DecimalFormat; (k_element <0 ) { System.out.println(" !!! k_element "+k_element); al.get(k_near).printelem();}

List listOut_kd = elemOut.get(k_kd); // начало сжатия списка выхода k_kd

ListIterator itrOut_kd = listOut_kd.listIterator(k_element);

while (itrOut_kd.hasNext()) // переопределение списка выхода k_kd

{ elem element =(elem) itrOut_kd.next(); // следующий элемент списка выхода k_kd

int number_al = element.number;

if (number_al <0 ) { System.out.println(" !!! number_al "+number_al); }

al.get(number_al).outelem = -1; // отписка от выхода kk

al.get(number_al).direct_elem = 0;

al.get(number_al).time_outelem = 0; };

while ((k_element) < listOut_kd.size()) {listOut_kd.remove(k_element); } //nn import java.text.DecimalFormat;_kd++;}

finis_out[k_kd]=listOut_kd.size();

if (k_out[k_kd]>=k_element) k_out[k_kd]=k_element-1;

if ((k_element-1) <0 ) { System.out.println(" !!! k_element-y "+k_element); } }

} }

} // конец обработки соседа снизу

if ((k_near=elemxx.yincrease) >=0) // сосед сверху в расчетной области (номер ячейки)

{ elemk_near = al.get(k_near); // ячейка соседа сверху

k_kd = elemk_near.outelem; // предписание выхода для соседа сверху

if (k_kd != kk) // сосед подлежит обработке

{ if ( k_kd < 0) // не приписан к выходу (обрабатываем ячейку и приписываем к выходу)

{ al.get(k_near).outelem = kk; // приписали к выходу kk

al.get(k_near).direct_elem import java.text.DecimalFormat; = -2; // y

al.get(k_near).time_outelem = elemxx.time_outelem + hy/elemk_near.velem();

elemOut.get(kk).add(al.get(k_near));

finis_out[kk]=finis_out[kk]+1;

// System.out.println("\n k_inc+y = "+k_near+" finis_out[kk] = "+finis_out[kk]);

// al.get(k_near).printelem();

}

else // обработка случая когда сосед слева приписан к выходу != kk

{ time_kd=elemk_near.time_outelem; // время достижения элемента k_inc от выхода != kk

if (time_kd <= 0) {System.out.println("\n !!! y time_kd= "+time_kd); elemk_near.printelem();}

time_elem = hy/elemk_near.velem();

time_kk = elemxx.time_outelem + time_elem; // время достижения import java.text.DecimalFormat; элемента k_near от выхода = kk

// если время достижения выхода kk значительно меньше чем k_kd ( != kk ),

if ((time_kk+time_elem) <= time_kd) // то выход для ряда ячеек переопределяется

{ al.get(k_near).outelem = kk; // приписали к выходу kk

al.get(k_near).direct_elem = -2; // y

al.get(k_near).time_outelem = elemxx.time_outelem + hy/elemk_near.velem();

elemOut.get(kk).add(al.get(k_near));

finis_out[kk]=finis_out[kk]+1;

System.out.println("\n k_yinc = "+k_near+" finis_out[kk] = "+finis_out[kk]);

// al.get(k_near).printelem();

int k_element = elemOut.get(k_kd).indexOf(elemk_near); // Элементы import java.text.DecimalFormat; удалить c k_element

if (k_element <0 ) { System.out.println(" !!! y k_element "+k_element); al.get(k_near).printelem();}

List listOut_kd = elemOut.get(k_kd); // начало сжатия списка выхода k_kd

ListIterator itrOut_kd = listOut_kd.listIterator(k_element);

while (itrOut_kd.hasNext()) // переопределение списка выхода k_kd

{ elem element =(elem) itrOut_kd.next(); // следующий элемент списка выхода k_kd

int number_al = element.number;

if (number_al <0 ) { System.out.println(" !!! +y number_al "+number_al); }

al.get(number_al).outelem = -1; // отписка от выхода kk

al.get(number_al).direct_elem = 0;

al.get(number_al).time_outelem = 0; };

while ((k_element) < listOut_kd import java.text.DecimalFormat;.size()) {listOut_kd.remove(k_element);} // nn_kd++;}

finis_out[k_kd]=listOut_kd.size();

if (k_out[k_kd]>=k_element) k_out[k_kd]=k_element-1;

if ((k_element-1) <0 ) { System.out.println(" !!! +y k_element "+k_element); } }

} }

} // конец обработки соседа сверху

bout[kk]=false;

int kfin = elemOut.get(kk).size(); // количество элементов в списке kk

if (k_out[kk]<(kfin-1)) {k_out[kk]=k_out[kk]+1; bout[kk]=true;}

} // цикл по выходному списку

elem_cen = false;

for(int kk=0; kk

{if (bout[kk] == true) {elem_cen = true; break; } }

} while (elem_cen); // do

// Печать

System.out.println(" \n Печать по import java.text.DecimalFormat; выходам");;

for (int i=1; i

for (int j=1; j

if (array[i][j]>=0) {number_elem=array[i][j]; System.out.print(al.get(number_elem).outelem+" ");}

else System.out.print(" "); }};

/* System.out.println(" \n Печать по типам");

for (int i=1; i

for (int j=1; j

if (array[i][j]>=0) {number_elem=array[i][j]; System.out.print(al.get(number_elem).type_elem+" ");}

else System.out.print(" "); }}; */

System.out.println(" \n Печать по направлениям ");

for (int i=1; i

for (int j=1; j

if (array[i import java.text.DecimalFormat;][j]>=0) {number_elem=array[i][j]; System.out.print(al.get(number_elem).direct_elem +" ");}

else System.out.print(" "); }};

/* System.out.println(" \n Номер в списке выхода ");

for (int i=1; i

for (int j=1; j

if (array[i][j]>=0) {number_elem=array[i][j]; elemxx= al.get(number_elem); int kkk=elemxx.outelem;

int nump=elemOut.get(kkk).indexOf(elemxx); System.out.print(nump+"("+kkk+")"+" ");}

else System.out.print(" "); }}; */

System.out.println(" \n Печать плотности распределения людей ");

// распределение людей по расчетной области

for (int i=1; i

for (int j=1; j

if (array[i][j]>=0) {number_elem=array[i][j]; people= al.get(number_elem).d_elem;

num_people=num_people+people*hx*hy; System.out.print(pip.format(people) +" ");}

else System.out.print(" "); }};

System.out.print("\n Number people "+pip.format(num_people) +" ");

/* // Расчет плотности потоков по спискам каждого из выходов

double nk0, nk_near, ntran ;

double d_tranzit, qout, qin, qmax_xx;

double elemS=hx*hy, elemL;

int num;

int ntime=20; // число проходов по времени

double kust=0.9; // устойчивость расчета при kust -> 0 ( kust<1 )

double tay= (Math.min(hx,hy)/100.0)*kust; // минут

boolean bb;

// for (int kk=0; kk

for(int ktime=0; ktime

{ time=time+tay;

for(int kk=0; kk

{ if ( elemOut.get(kk).isEmpty() )

{System.out.println("\n !!(427)!! elemOut.get(kk).isEmpty"); continue; } // пустая очередь на выход kk

List listOutkk = elemOut.get(kk);

ListIterator itrOutkk = listOutkk.listIterator(); // начало списка выхода kk

while (itrOutkk.hasNext()) // обработка списка выхода kk

{elemxx =(elem) itrOutkk.next(); //элемент списка выхода kk

if ( elemxx.outelem != kk ) {System.out.println("\n !!(432)!!elemxx.outelem != kk "+kk); continue; }

num=elemOut.get(kk).indexOf(elemxx); // номер элемента в списке выхода kk

int direct = elemxx.direct_elem; // Обработка узла (стока) списка

// System.out.println("Номер элемента в очереди "+num+"("+kk import java.text.DecimalFormat;+") "+" Направление выхода "+direct);

// Сток людей из элемента через выход из расчетной области

if (num == 0){ if (elemxx.type_elem !=5 )System.out.println("\n!437! Mistake!!elemk_near.type_elem != 5 ");

if (elemxx.d_elem > 0){ nk0=elemxx.d_elem*elemS;

qout=elemxx.velem(outL[kk])*elemxx.d_elem; ntran= outL[kk]*qout*tay;

if (ntran > nk0) ntran = nk0;

peopleOut[kk] = peopleOut[kk]+ ntran; elemxx.d_elem = elemxx.d_elem - ntran/elemS;

} }

/* kjgkjg */ qmax_xx = 0; // Элемент обрабатывается, если количество людей меньше предельного значения

bb = ((elemxx.type_elem == 2) | (elemxx.type_elem == 5));

if (bb){ int num_Door = elemxx.number_Door; elemL=al_Door.get(num_Door).l import java.text.DecimalFormat;;

qmax_xx= elemxx.dmax(elemL);} else qmax_xx= elemxx.dmax();

if (elemxx.d_elem < qmax_xx)

{ switch(direct) {

case -1: // Поток по направлению -х

{ if ((k_near=elemxx.xincrease) >=0) // сосед +x в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка справа от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if(elemk_near.direct_elem == direct ) { if (elemk_near.d_elem >0)

{ if (elemk_near.type_elem == 5) System.out.println("\n!453! Mistake!!elemk_near.type_elem == 5 ");

nk_near=elemk_near.d_elem*elemS;

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

elemL=al_Door.get import java.text.DecimalFormat;(num_Door).l; qin = elemk_near.velem(elemL)*elemk_near.d_elem;}

else { elemL=hy; qin = elemk_near.velem()*elemk_near.d_elem;}

ntran =elemL*qin*tay; if (ntran > nk_near) ntran = nk_near;

d_tranzit = (qmax_xx-elemxx.d_elem)*elemS; // вместимость элемента, чел.

if ( d_tranzit > ntran ) { elemxx.d_elem = elemxx.d_elem + ntran/elemS;

elemk_near.d_elem = elemk_near.d_elem - ntran/elemS; }

else { elemxx.d_elem = elemxx.d_elem + d_tranzit/elemS;

elemk_near.d_elem = elemk_near.d_elem - d_tranzit/elemS; }

} } } } }; break;

case 1: // Поток по направлению х

{ if ((k_near=elemxx.xreduction) >=0) // сосед -x import java.text.DecimalFormat; в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка -x от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if(elemk_near.direct_elem == direct ) { if (elemk_near.d_elem >0)

{ if (elemk_near.type_elem == 5) System.out.println("\n!466! Mistake!!elemk_near.type_elem == 5 ");

nk_near=elemk_near.d_elem*elemS;

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

elemL=al_Door.get(num_Door).l; qin = elemk_near.velem(elemL)*elemk_near.d_elem;}

else { elemL = hy; qin = elemk_near.velem()*elemk_near.d_elem;}

ntran =elemL*qin import java.text.DecimalFormat;*tay; if (ntran > nk_near) ntran = nk_near;

d_tranzit = (qmax_xx-elemxx.d_elem)*elemS; // вместимость элемента, чел.

if ( d_tranzit > ntran ) { elemxx.d_elem = elemxx.d_elem + ntran/elemS;

elemk_near.d_elem = elemk_near.d_elem - ntran/elemS; }

else { elemxx.d_elem = elemxx.d_elem + d_tranzit/elemS;

elemk_near.d_elem = elemk_near.d_elem - d_tranzit/elemS; }

} } } } }; break;

case -2: // Поток по направлению -y

{ if ((k_near=elemxx.yincrease) >=0) // сосед +y в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка +y от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if(elemk import java.text.DecimalFormat;_near.direct_elem == direct ) { if (elemk_near.d_elem >0)

{ if (elemk_near.type_elem == 5) System.out.println("\n!482! Mistake!!elemk_near.type_elem == 5 ");

nk_near=elemk_near.d_elem*elemS;

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

elemL=al_Door.get(num_Door).l; qin = elemk_near.velem(elemL)*elemk_near.d_elem;}

else { elemL =hx; qin = elemk_near.velem()*elemk_near.d_elem;}

ntran =elemL*qin*tay; if (ntran > nk_near) ntran = nk_near;

d_tranzit = (qmax_xx-elemxx.d_elem)*elemS; // вместимость элемента, чел.

if ( d_tranzit > ntran ) { elemxx.d_elem import java.text.DecimalFormat; = elemxx.d_elem + ntran/elemS;

elemk_near.d_elem = elemk_near.d_elem - ntran/elemS; }

else { elemxx.d_elem = elemxx.d_elem + d_tranzit/elemS;

elemk_near.d_elem = elemk_near.d_elem - d_tranzit/elemS; }

} } } } }; break;

case 2: // Поток по направлению y

{ if ((k_near=elemxx.yreduction) >=0) // сосед -y в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка -y от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if(elemk_near.direct_elem == direct ) { if (elemk_near.d_elem >0)

{ if (elemk_near.type_elem == 5) System.out.println("\n!498! Mistake!!elemk_near.type_elem == 5 ");

nk import java.text.DecimalFormat;_near=elemk_near.d_elem*elemS;

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

elemL=al_Door.get(num_Door).l; qin = elemk_near.velem(elemL)*elemk_near.d_elem;}

else { elemL = hx; qin = elemk_near.velem()*elemk_near.d_elem;}

ntran =elemL*qin*tay; if (ntran > nk_near) ntran = nk_near;

d_tranzit = (qmax_xx-elemxx.d_elem)*elemS; // вместимость элемента, чел.

if ( d_tranzit > ntran ) { elemxx.d_elem = elemxx.d_elem + ntran/elemS;

elemk_near.d_elem = elemk_near.d_elem - ntran/elemS; }

else { elemxx.d_elem = elemxx.d_elem + d_tranzit/elemS;

elemk_near import java.text.DecimalFormat;.d_elem = elemk_near.d_elem - d_tranzit/elemS; }

} } } } }; break; }; // swicth

if ((direct == 1) | (direct == -1))

{ if ((k_near=elemxx.yincrease) >=0) // сосед +y в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка +y от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if(elemk_near.direct_elem == -2 ) { if (elemk_near.d_elem >0)

{ if (elemk_near.type_elem == 5) System.out.println("\n!515! Mistake!!elemk_near.type_elem == 5 ");

nk_near=elemk_near.d_elem*elemS;

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

elemL=al_Door.get(num_Door).l; qin = elemk import java.text.DecimalFormat;_near.velem(elemL)*elemk_near.d_elem;}

else { elemL=hx; qin = elemk_near.velem()*elemk_near.d_elem;}

ntran =elemL*qin*tay; if (ntran > nk_near) ntran = nk_near;

if (elemxx.d_elem < qmax_xx) {

d_tranzit = (qmax_xx-elemxx.d_elem)*elemS; // вместимость элемента, чел.

if ( d_tranzit > ntran ) { elemxx.d_elem = elemxx.d_elem + ntran/elemS;

elemk_near.d_elem = elemk_near.d_elem - ntran/elemS; }

else { elemxx.d_elem = elemxx.d_elem + d_tranzit/elemS;

elemk_near.d_elem = elemk_near.d_elem - d_tranzit/elemS; } }

} } } };

if ((k_near=elemxx.yreduction) >=0) // сосед -y в расчетной области (номер ячейки)

{elemk import java.text.DecimalFormat;_near = al.get(k_near); // ячейка -y от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if(elemk_near.direct_elem == 2 ) { if (elemk_near.d_elem >0)

{ if (elemk_near.type_elem == 5) System.out.println("\n!525! Mistake!!elemk_near.type_elem == 5 ");

nk_near=elemk_near.d_elem*elemS;

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

elemL=al_Door.get(num_Door).l; qin = elemk_near.velem(elemL)*elemk_near.d_elem;}

else { elemL=hx; qin = elemk_near.velem()*elemk_near.d_elem;}

ntran = elemL*qin*tay; if (ntran > nk_near) ntran = nk_near import java.text.DecimalFormat;;

if (elemxx.d_elem < qmax_xx) {

d_tranzit = (qmax_xx-elemxx.d_elem)*elemS; // вместимость элемента, чел.

if ( d_tranzit > ntran ) { elemxx.d_elem = elemxx.d_elem + ntran/elemS;

elemk_near.d_elem = elemk_near.d_elem - ntran/elemS; }

else { elemxx.d_elem = elemxx.d_elem + d_tranzit/elemS;

elemk_near.d_elem = elemk_near.d_elem - d_tranzit/elemS; } }

} } } };

};

if ((direct == 2) | (direct == -2))

{ if ((k_near=elemxx.xincrease) >=0) // сосед +x в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка +x от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if(elemk_near import java.text.DecimalFormat;.direct_elem == -1 ) { if (elemk_near.d_elem >0)

{ if (elemk_near.type_elem == 5) System.out.println("\n!541! Mistake!!elemk_near.type_elem == 5 ");

nk_near=elemk_near.d_elem*elemS;

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

elemL=al_Door.get(num_Door).l; qin = elemk_near.velem(elemL)*elemk_near.d_elem;}

else { elemL=hy; qin = elemk_near.velem()*elemk_near.d_elem;}

ntran =elemL*qin*tay; if (ntran > nk_near) ntran = nk_near;

if (elemxx.d_elem < qmax_xx) {

d_tranzit = (qmax_xx-elemxx.d_elem)*elemS; // вместимость элемента, чел.

if ( d_tranzit import java.text.DecimalFormat; > ntran ) { elemxx.d_elem = elemxx.d_elem + ntran/elemS;

elemk_near.d_elem = elemk_near.d_elem - ntran/elemS; }

else { elemxx.d_elem = elemxx.d_elem + d_tranzit/elemS;

elemk_near.d_elem = elemk_near.d_elem - d_tranzit/elemS; } }

} } } };

if ((k_near=elemxx.xreduction) >=0) // сосед -x в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка -x от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if(elemk_near.direct_elem == 1 ) { if (elemk_near.d_elem >0)

{ if (elemk_near.type_elem == 5) System.out.println("\n!555! Mistake!!elemk_near.type_elem == 5 ");

nk_near=elemk_near.d import java.text.DecimalFormat;_elem*elemS;

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

elemL=al_Door.get(num_Door).l; qin = elemk_near.velem(elemL)*elemk_near.d_elem;}

else { elemL=hy; qin = elemk_near.velem()*elemk_near.d_elem;}

ntran = elemL*qin*tay; if (ntran > nk_near) ntran = nk_near;

if (elemxx.d_elem < qmax_xx) {

d_tranzit = (qmax_xx-elemxx.d_elem)*elemS; // вместимость элемента, чел.

if ( d_tranzit > ntran ) { elemxx.d_elem = elemxx.d_elem + ntran/elemS;

elemk_near.d_elem = elemk_near.d_elem - ntran/elemS; }

else { elemxx.d_elem = elemxx.d_elem + d_tranzit/elemS import java.text.DecimalFormat;;

elemk_near.d_elem = elemk_near.d_elem - d_tranzit/elemS; } }

} } } };

} } } };

}

peopleTotal=0;

for (int kp=0; kp

{ peopleTotal=peopleTotal+ peopleOut[kp];}

System.out.println(" \n \n Печать распределения людей Time="+time);

// DecimalFormat pip = new DecimalFormat("#.00");

num_people=0; // распределение людей по расчетной области

double pOut=0;

for (int i=1; i

for (int j=1; j

if (array[i][j]>=0) {number_elem=array[i][j]; people= al.get(number_elem).d_elem; //*hx*hy;

num_people=num_people+people*hx*hy; System.out.print(pip.format(people) +" ");}

else System.out.print(" "); }};

System.out import java.text.DecimalFormat;.println("\n Number people "+pip.format(num_people) +" ");

for (int kp=0; kp

{ pOut=pOut+ peopleOut[kp];

System.out.println(" Number people in out ("+kp+")= "+pip.format(peopleOut[kp])); };

double balance=pOut+ num_people;

System.out.println("\n Common number of people on out "+pip.format(pOut) +

"\n Balance N(in)+N(out) = "+pip.format(balance));

} // do Главный цикл по выходу всех людей из здания */

// while ((nn - peopleTotal)>0);

} }

/*

//оПРЕДЕЛЕНИЕ dmax

elem elemdd =new elem(100,0, 0,0,0,0,0,0);

double vElem, dvElem, dMax, ffElem, ffElemOld, ffMin, ddd, d1, ddp=0.005; // dvMax,

double qmax[]={16.5, 16.5, 19.6, 16.0, 11.0, 19.6}; // м/мин

double dmax[] = new double import java.text.DecimalFormat; [10];

int priz=0;

for (int el=0; el

{ ffMin=1.0e+5; dMax=0; ffElemOld=0;

ddd=zdan1.dElemMax*0.9;

do

{ elemdd.d_elem = ddd=ddd-ddp/elemS; if ( (el == 2) | (el == 5) ) { elemdd.type_elem = 2; vElem=elemdd.velem(1.0);}

else { elemdd.type_elem = 0; vElem=elemdd.velem();}

dvElem= ddd*vElem; ffElem = dvElem - qmax[el]/(zdan1.fp) ;

if (ffElem*ffElemOld < 0) { priz=0; dMax=ddd; ffMin= ffElem; break; }; ffElemOld=ffElem;

if (Math.abs(ffMin) > (d1=Math.abs(ffElem))) {priz=100; ffMin=ffElem; dMax=ddd; } }

while (ddd > 0.5);

dmax[el]=dMax;

System.out.println(" el= "+pip.format(el)+" priz= "+priz+" ffMin= "+pip.format(ffMin)+ " Dmax= "+ pip.format(dMax));

} System.out.println(Arrays.toString(dmax));

*/

// Отладка import java.text.DecimalFormat; (печать)

/*

double dp=0.1;

for(int p= 1; p<30; p++) {

elemdd.d_elem = p*dp/elemS;

System.out.print("\n p= "+pip.format(p*dp)+" D= "+ pip.format(elemdd.d_elem)+

" V= "+ pip.format(elemdd.velem())+

" VD "+ pip.format(elemdd.velem()*elemdd.d_elem)+" dmax= "+ pip.format(elemdd.dmax())); } */

/*

//if (dvElem > dvMax) {dvMax = dvElem; dMax=ddd; }};

*/

//dmaxtt=qmax[el]/(zdan1.fp*vtt);

// if (dmaxtt > dmaxttx) {dmaxttx=dmaxtt; vttx=vtt; dmax[el]= dmaxttx ;

/*if ( (el == 0) | (el == 4) )

System.out.print("\n ff= "+pip.format(ffElem)+ " D= "+ pip.format(ddd)+ " V= "+ pip.format(vElem)+

" VD= "+ pip.format(dvElem) + " ffMin= "+pip.format(ffMin)+ " Dmax= "+ pip.format import java.text.DecimalFormat;(dMax) );

версия от 27.04. 2012

{ switch(direct) {

case -1: // Поток по направлению -х

{ if ((k_near=elemxx.xincrease) >=0) // сосед +x в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка справа от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if(elemk_near.direct_elem == direct ) { if (elemk_near.d_elem >0)

{ if (elemk_near.type_elem == 5) System.out.println("\n!453! Mistake!!elemk_near.type_elem == 5 ");

nk_near=elemk_near.d_elem*elemS;

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

elemL=al_Door.get(num_Door).l; qmax_near=elemk_near.dmax(elemL); qin=0;

if (elemxx import java.text.DecimalFormat;.d_elem <= qmax_near) qin = elemk_near.velem(elemL)*elemk_near.d_elem;}

else { qmax_near=elemk_near.dmax(); elemL=hy; qin=0;

if (elemxx.d_elem <= qmax_near) qin = elemk_near.velem()*elemk_near.d_elem;}

ntran =elemL*qin*tay; if (ntran > nk_near) ntran = nk_near;

elemxx.d_elem = elemxx.d_elem + ntran/elemS;

elemk_near.d_elem = elemk_near.d_elem - ntran/elemS;

} } } } }; break;

case 1: // Поток по направлению х

{ if ((k_near=elemxx.xreduction) >=0) // сосед -x в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка -x от соседа

if(elemk_near.outelem == kk) // ячейка соседняя import java.text.DecimalFormat; относится к выходу kk

{ if(elemk_near.direct_elem == direct ) { if (elemk_near.d_elem >0)

{ if (elemk_near.type_elem == 5) System.out.println("\n!466! Mistake!!elemk_near.type_elem == 5 ");

nk_near=elemk_near.d_elem*elemS;

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

elemL=al_Door.get(num_Door).l; qmax_near=elemk_near.dmax(elemL); qin=0;

if (elemxx.d_elem <= qmax_near) qin = elemk_near.velem(elemL)*elemk_near.d_elem;}

else { qmax_near=elemk_near.dmax(); elemL = hy; qin=0;

if (elemxx.d_elem <= qmax_near) qin = elemk_near.velem()*elemk_near import java.text.DecimalFormat;.d_elem;}

ntran =elemL*qin*tay; if (ntran > nk_near) ntran = nk_near;

elemxx.d_elem = elemxx.d_elem + ntran/elemS;

elemk_near.d_elem = elemk_near.d_elem - ntran/elemS;

} } } } }; break;

case -2: // Поток по направлению -y

{ if ((k_near=elemxx.yincrease) >=0) // сосед +y в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка справа от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if(elemk_near.direct_elem == direct ) { if (elemk_near.d_elem >0)

{ if (elemk_near.type_elem == 5) System.out.println("\n!482! Mistake!!elemk_near.type_elem == 5 ");

nk_near=elemk_near.d_elem*elemS import java.text.DecimalFormat;;

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

elemL=al_Door.get(num_Door).l; qmax_near=elemk_near.dmax(elemL); qin=0;

if (elemxx.d_elem <= qmax_near) qin = elemk_near.velem(elemL)*elemk_near.d_elem;}

else { qmax_near=elemk_near.dmax(); elemL =hx; qin=0;

if (elemxx.d_elem <= qmax_near) qin = elemk_near.velem()*elemk_near.d_elem;}

ntran =elemL*qin*tay; if (ntran > nk_near) ntran = nk_near;

elemxx.d_elem = elemxx.d_elem + ntran/elemS;

elemk_near.d_elem = elemk_near.d_elem - ntran/elemS;

} } } } }; break;

case 2: // Поток по направлению y

{ if ((k_near=elemxx import java.text.DecimalFormat;.yreduction) >=0) // сосед -y в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка -y от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if(elemk_near.direct_elem == direct ) { if (elemk_near.d_elem >0)

{ if (elemk_near.type_elem == 5) System.out.println("\n!498! Mistake!!elemk_near.type_elem == 5 ");

nk_near=elemk_near.d_elem*elemS;

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

elemL=al_Door.get(num_Door).l; qmax_near=elemk_near.dmax(elemL); qin=0;

if (elemxx.d_elem <= qmax_near) qin = elemk_near.velem(elemL import java.text.DecimalFormat;)*elemk_near.d_elem;}

else { qmax_near=elemk_near.dmax(); elemL = hx; qin=0;

if (elemxx.d_elem <= qmax_near) qin = elemk_near.velem()*elemk_near.d_elem;}

ntran =elemL*qin*tay; if (ntran > nk_near) ntran = nk_near;

elemxx.d_elem = elemxx.d_elem + ntran/elemS;

elemk_near.d_elem = elemk_near.d_elem - ntran/elemS;

} } } } }; break; }; // swicth */

/*

elem elemdd =new elem(100,0, 0,0,0,0,0,0);

for(int p= 1; p<30; p++) {

double elemSS=1;

elemdd.d_elem = p/elemSS;

System.out.print("\n p= "+p+" D= "+ pip.format(elemdd.d_elem)+

" V= "+ pip.format(elemdd.velem())+" dmax= "+ pip.format(elemdd.dmax())); } */

/*

for (int i=1; i

for (int j=1; j

if (array[i][j]>=0) {number_elem=array[i][j]; al.get(number_elem).d_elem= al.get(number_elem).d_new;};

*/

/* // ******

if ((direct == 1) | (direct == -1)) {

{qplus2=0;

if ((k_near=elemxx.yincrease) >=0) // сосед + в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка +y от соседа

if(elemk_near.outelem == kk) { // ячейка соседняя относится к выходу kk

if( (elemk_near.d_elem > 0) & (elemk_near.direct_elem == -2) )

{if (elemk_near.type_elem == 5) System.out.println("\n!(439)!! Mist-2!!elemk_near.type_elem == 5 ");

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

double ll=al import java.text.DecimalFormat;_Door.get(num_Door).l;

if (elemxx.d_elem <= elemk_near.dmax(ll)) qplus2=elemk_near.velem(ll)*elemk_near.d_elem;} // 2

else { if (elemxx.d_elem <=elemk_near.dmax()) qplus2=elemk_near.velem()*elemk_near.d_elem;} } } } };

{qmin2=0;

if ((k_near=elemxx.yreduction) >=0) // сосед - в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка -y от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

if( (elemk_near.d_elem > 0) & (elemk_near.direct_elem == 2) )

{if (elemk_near.type_elem == 5) System.out.println("\n!(449)!! Mist-2!!elemk_near.type_elem == 5 ");

if (elemk_near.type_elem == 2){ int num_Door import java.text.DecimalFormat; = elemk_near.number_Door;

double ll=al_Door.get(num_Door).l;

if (elemxx.d_elem <= elemk_near.dmax(ll)) qmin2=elemk_near.velem(ll)*elemk_near.d_elem;} // 2

else { if (elemxx.d_elem <=elemk_near.dmax()) qmin2=elemk_near.velem()*elemk_near.d_elem;} } } };

dqy= (qplus2+qmin2)/hy; }; //((direct == 1) | (direct == -1))

if ((direct == 2) | (direct == -2)) {

{qplus1=0;

if ((k_near=elemxx.xincrease) >=0) // сосед + в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка +x от соседа

if(elemk_near.outelem == kk) { // ячейка соседняя относится к выходу kk

if( (elemk_near.d_elem > 0) & (elemk_near.direct_elem == -1) )

{if (elemk_near.type_elem == 5) System.out import java.text.DecimalFormat;.println("\n!(461)!! Mist-2!!elemk_near.type_elem == 5 ");

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

double ll=al_Door.get(num_Door).l;

if (elemxx.d_elem <= elemk_near.dmax(ll)) qplus1=elemk_near.velem(ll)*elemk_near.d_elem;} // 2

else { if (elemxx.d_elem <=elemk_near.dmax()) qplus1=elemk_near.velem()*elemk_near.d_elem;} } } } };

{qmin1=0;

if ((k_near=elemxx.xreduction) >=0) // сосед - в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка -x от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

if( (elemk_near.d_elem import java.text.DecimalFormat; > 0) & (elemk_near.direct_elem == 1) )

{if (elemk_near.type_elem == 5) System.out.println("\n!(471)!! Mist-2!!elemk_near.type_elem == 5 ");

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

double ll=al_Door.get(num_Door).l;

if (elemxx.d_elem <= elemk_near.dmax(ll)) qmin1=elemk_near.velem(ll)*elemk_near.d_elem;} // 2

else { if (elemxx.d_elem <=elemk_near.dmax()) qmin1=elemk_near.velem()*elemk_near.d_elem;} } } };

dqx= (qplus1+qmin1)/hx; };

//***

*

*/

/* else {qmin1=0;

if ((k_near=elemxx.xreduction) >=0) // сосед слева в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка слева от соседа

if import java.text.DecimalFormat;(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if (elemxx.d_elem >0) {

if (elemxx.type_elem == 2){ int num_Door = elemxx.number_Door;

double ll=al_Door.get(num_Door).l;

if (elemk_near.d_elem <= elemxx.dmax(ll)) qmin1=elemxx.velem(ll)*elemxx.d_elem;} // 2

else { if (elemk_near.d_elem <= elemxx.dmax()) qmin1=elemxx.velem()*elemxx.d_elem;} }

} else System.out.println(" !484! elemk_near.outelem != kk "+elemk_near.outelem + " kk "+ kk);

} else System.out.println(" !485! k_near=elemxx.xreduction !>=0 "+k_near); };

*/

/* dvx=-(vplus1-vmin1)/hx;

{vplus2=0;

if ((k_near=elemxx.yincrease) >=0) // сосед + в расчетной области (номер ячейки)

{elemk_near import java.text.DecimalFormat; = al.get(k_near); // ячейка +y от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if (elemk_near.type_elem == 5) System.out.println("\n!!! Mist-2!!elemk_near.type_elem == 5 ");

if (elemk_near.d_elem <= elemxx.dmax()) vplus1= elemxx.velem();}

} };

{vmin2=0;

if ((k_near=elemxx.yreduction) >=0) // сосед - в расчетной области (номер ячейки)

{elemk_near = al.get(k_near); // ячейка -y от соседа

if(elemk_near.outelem == kk) // ячейка соседняя относится к выходу kk

{ if (elemk_near.type_elem == 5) System.out.println("\n!!! Mist-3!!elemk_near.type_elem == 5 ");

if (elemxx.d_elem <= elemk_near.dmax()) vmin1= elemk_near.velem();}

} };

dvy= (vplus import java.text.DecimalFormat;2-vmin2)/hy;

{ qmax_near=elemk_near.dmax();

if (qmax_near <= elemxx.dmax()) vplus2= elemxx.velem(); }}};

iuyruyrfuff

if (elemk_near.type_elem == 2){ int num_Door = elemk_near.number_Door;

Дата добавления: 2015-10-21; просмотров: 2 | Нарушение авторских прав


documentapfshor.html
documentapfsoyz.html
documentapfswjh.html
documentapftdtp.html
documentapftldx.html
Документ import java.text.DecimalFormat;