эвакуация 3
.docximport 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) относится к центру ячейки
// int Nx=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[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 Источника 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 = 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<Nx;i++)
for(int j=0;j<Ny; j++) array[i][j]=out;
for (int i=1;i<Nx-1;i++)
for(int j=1;j<Ny1; j++) array[i][j]=in;
for (int i=Nx1;i<=Nx2;i++)
for(int j=1;j<Ny-1; j++) array[i][j]=in;
for (int k=0; k<n_Door; k++){
switch(direcDoor[k]){
case 1: int kki=coorDoor[k][0], kkj=coorDoor[k][1] ;
for(int j=1;j<Ny-1; j++) array[kki][j]=out; array[kki][kkj]=in ; break;
case 2: int kkjj=coorDoor[k][1], kkii=coorDoor[k][0] ;
for(int i=1;i<Nx-1; i++) array[i][kkjj]=out; array[kkii][kkjj]=in ; break;
default: { System.out.println(" !59! Mistake direcDoor[k] "+direcDoor[k]);}; } // ошибка
}
/* System.out.println("initial state ");
for(int i=0; i<Nx;i++) System.out.println(Arrays.toString(array[i]));
*/ // Переопределение массива = задание номера ячейки в области расчета
int number=0;
for (int i=0;i<Nx; i++)
for (int j=0;j<Ny; j++) if (array[i][j]<0) continue;
else {array[i][j]=number; number++; } ;
/* System.out.println("number of elements ");
for(int i=0; i<Nx;i++) System.out.println(Arrays.toString(array[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 = 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... в расчетной области (включая двери для выхода из расчетной обл.)
// Определение максимальной плотности потока 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<qmax.length; 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 < 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<elem> al = new ArrayList<elem>(); // базовый список ячеек
ArrayList<doorElem> al_Door = new ArrayList<doorElem>(); // базовый список дверей
ArrayList<ArrayList<elem>> elemOut = new ArrayList<ArrayList<elem>>();// Списки на выход (n_out);
for (int ii = 0; ii < n_Out; ii++) elemOut.add(new ArrayList<elem>());
int k_out[]= new int[n_Out]; // номер обрабатываемой ячейки списка выхода
int finis_out[]= new int[n_Out]; // номер последней ячейки списка выхода
int k_Door = 0; // номер двери
for (int i=1; i<Nx-1; i++)
for (int j=1; j<Ny-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_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<n_Out; 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]; // максимальная плотнеость
elem1.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<n_Door; 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<n_in; 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);}
// Формирование списков элементов для каждого выхода 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;
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<n_Out; kk++) peopleOut[kk]=0;
/* main do
do {*/
for (int kkkk=0; kkkk<2; kkkk++)
{
klist=0; elem_cen = true;
do // Формирование списков от каждого выхода
{ klist++; // число проходов по списку выходов
for(int kk=0; kk<n_Out; 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 (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) // сосед справа в расчетной области (номер ячейки) Индекс 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; // предписание выхода для соседа справа
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 + 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
// если время достижения выхода 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 <0 ) { System.out.println(" !220! k_element "+k_element); al.get(k_near).printelem();}
List<elem> 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_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.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
// если время достижения выхода 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 <0 ) { System.out.println(" !264! k_element "+k_element); al.get(k_near).printelem();}
List<elem> 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++;}
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_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 от выхода = 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 (k_element <0 ) { System.out.println(" !!! k_element "+k_element); al.get(k_near).printelem();}
List<elem> 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++;}
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 = -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; // время достижения элемента 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); // Элементы удалить c k_element
if (k_element <0 ) { System.out.println(" !!! y k_element "+k_element); al.get(k_near).printelem();}
List<elem> 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.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<n_Out; kk++) // Выходы
{if (bout[kk] == true) {elem_cen = true; break; } }
} while (elem_cen); // do
// Печать
System.out.println(" \n Печать по выходам");;
for (int i=1; i<Nx-1; i++) {System.out.println();
for (int j=1; j<Ny-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<Nx-1; i++) {System.out.println();
for (int j=1; j<Ny-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<Nx-1; i++) {System.out.println();
for (int j=1; j<Ny-1; j++) {
if (array[i][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<Nx-1; i++) {System.out.println();
for (int j=1; j<Ny-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<Nx-1; i++) {System.out.println();
for (int j=1; j<Ny-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<n_Out; kk++) peopleOut[kk]=0; */
for(int ktime=0; ktime<ntime; ktime++)
{ time=time+tay;
for(int kk=0; kk<n_Out; kk++) // по выходам
{ if ( elemOut.get(kk).isEmpty() )
{System.out.println("\n !!(427)!! elemOut.get(kk).isEmpty"); continue; } // пустая очередь на выход kk
List<elem> 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+") "+" Направление выхода "+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;
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(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 в расчетной области (номер ячейки)
{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*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_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 = 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 ");