#define OP_F(name) (&m6805_base_device::name<false>) #define OP_IM(name) (&m6805_base_device::name<addr_mode::IM>) #define OP_DI(name) (&m6805_base_device::name<addr_mode::DI>) #define OP_EX(name) (&m6805_base_device::name<addr_mode::EX>) #define OP_IX(name) (&m6805_base_device::name<addr_mode::IX>) #define OP_IX1(name) (&m6805_base_device::name<addr_mode::IX1>) #define OP_IX2(name) (&m6805_base_device::name<addr_mode::IX2>) const m6805_base_device::op_handler_table m6805_base_device::s_hmos_ops = { /* 0/8 1/9 2/A 3/B 4/C 5/D 6/E 7/F */ /* 0 */ OP(brset<0>),OP(brclr<0>),OP(brset<1>),OP(brclr<1>),OP(brset<2>),OP(brclr<2>),OP(brset<3>),OP(brclr<3>), OP(brset<4>),OP(brclr<4>),OP(brset<5>),OP(brclr<5>),OP(brset<6>),OP(brclr<6>),OP(brset<7>),OP(brclr<7>), /* 1 */ OP(bset<0>), OP(bclr<0>), OP(bset<1>), OP(bclr<1>), OP(bset<2>), OP(bclr<2>), OP(bset<3>), OP(bclr<3>), OP(bset<4>), OP(bclr<4>), OP(bset<5>), OP(bclr<5>), OP(bset<6>), OP(bclr<6>), OP(bset<7>), OP(bclr<7>), /* 2 */ OP_T(bra), OP_F(bra), OP_T(bhi), OP_F(bhi), OP_T(bcc), OP_F(bcc), OP_T(bne), OP_F(bne), OP_T(bhcc), OP_F(bhcc), OP_T(bpl), OP_F(bpl), OP_T(bmc), OP_F(bmc), OP_T(bil), OP_F(bil), /* 3 */ OP_DI(neg), OP(illegal), OP(illegal), OP_DI(com), OP_DI(lsr), OP(illegal), OP_DI(ror), OP_DI(asr), OP_DI(lsl), OP_DI(rol), OP_DI(dec), OP(illegal), OP_DI(inc), OP_DI(tst), OP(illegal), OP_DI(clr), /* 4 */ OP(nega), OP(illegal), OP(illegal), OP(coma), OP(lsra), OP(illegal), OP(rora), OP(asra), OP(lsla), OP(rola), OP(deca), OP(illegal), OP(inca), OP(tsta), OP(illegal), OP(clra), /* 5 */ OP(negx), OP(illegal), OP(illegal), OP(comx), OP(lsrx), OP(illegal), OP(rorx), OP(asrx), OP(lslx), OP(rolx), OP(decx), OP(illegal), OP(incx), OP(tstx), OP(illegal), OP(clrx), /* 6 */ OP_IX1(neg), OP(illegal), OP(illegal), OP_IX1(com), OP_IX1(lsr), OP(illegal), OP_IX1(ror), OP_IX1(asr), OP_IX1(lsl), OP_IX1(rol), OP_IX1(dec), OP(illegal), OP_IX1(inc), OP_IX1(tst), OP(illegal), OP_IX1(clr), /* 7 */ OP_IX(neg), OP(illegal), OP(illegal), OP_IX(com), OP_IX(lsr), OP(illegal), OP_IX(ror), OP_IX(asr), OP_IX(lsl), OP_IX(rol), OP_IX(dec), OP(illegal), OP_IX(inc), OP_IX(tst), OP(illegal), OP_IX(clr), /* 8 */ OP(rti), OP(rts), OP(illegal), OP(swi), OP(illegal), OP(illegal), OP(illegal), OP(illegal), OP(illegal), OP(illegal), OP(illegal), OP(illegal), OP(illegal), OP(illegal), OP(illegal), OP(illegal), /* 9 */ OP(illegal), OP(illegal), OP(illegal), OP(illegal), OP(illegal), OP(illegal), OP(illegal), OP(tax), OP(clc), OP(sec), OP(cli), OP(sei), OP(rsp), OP(nop), OP(illegal), OP(txa),
void main(int argc, char *argv[]) { // ------------------------------------------------------- // Ввод начальных данных // ------------------------------------------------------- // if (strcmp(argv[2], "dialog")==0) // Вход из программы "диалог" strcpy(namezad, argv[1]); kadr_im(); // Прямой вход i=argc; i=schitn(); // Считывание начальной постановки if (i!=0) {cout<<" Нет начальной постановки ! ";exit(1);} i=schito(); // Задание или просмотр параметров счета if (i!=0) {cout<<" Не могу обратиться к файлу <.о> ! ";exit (1);} printf("\nНачало счета задачи %s\n\n",namezad); razresh = atof(prr); kur = atof(chk); delta = atof(delt); ststp = atoi(sho); stzap = atoi(shz); maxvisc = atof(vazmax); minvisc = atof(vazmin); markt = atoi(mkt); ncr = (int)(dlina*razresh); if (ncr>MNCR) { cout<<" Количество ячеек расчетного поля больше допустимого !! "; exit(1);} part = 2*ncr; // Константы обезразмеривания lbez = 1/razresh; // Длина ячейки (мм) robez= atof(obzro); // Плотность (г/см**3) vbez = atof(obzv); // Скорость (км/с) ebez = vbez*vbez; // Энергия (км/с)**2 tbez = lbez/vbez; // Время (мкс) pbez = robez*vbez*vbez; // Давление (Гпа) eps = 1e-10; // Обрезание производных pkr = -1.0/pbez; // Ограничение снизу по давлению krdr = 0.01; // Критерий дробления частицы // ------------------------------------------------------- // Задание параметров частиц // ------------------------------------------------------- for (i=0; i<=part; i++) { m[i] = 0; nb[i] = 0; r[i] = 0.0; v[i] = 0.0; ro[i] = 0.0; e[i] = 0.0; l[i] = 0.0; p[i] = 0.0; } // Конец очистки параметров частиц for (np=0,k=0; k<ksl; k++) { // Цикл по слоям if (nus[k]==1) index=1; // Ид.газ if (nus[k]==2) { index=3; // Тэт Curs[k][0]/=robez; Curs[k][1]/=pbez;} if (nus[k]==3) { index=3; // D-u Curs[k][0]/=robez; Curs[k][1]/=vbez;} uro=Curs[k][index]/robez; // Начальная плотность ue0=Curs[k][index+1]/ebez; // Начальная энергия kchsl=(sr2[k]-sr1[k])*razresh; // Количество частиц в теле cout<<" kchsl "<<kchsl<<" sr1[k] "<<sr1[k]<<" sr2[k] "<<sr2[k]<<" razresh "<<razresh; for (j=0,i=np+1; i<=np+kchsl; j++,i++) { // Задание параметров частиц m[i] = mrk[k]-1; // Маркеры: 0-первое тело, 1-второе... !!! nb[i] = nus[k]; r[i] = (sr1[k]*razresh+j+0.5); v[i] = sv[k]/vbez; ro[i] = uro; e[i] = ue0+v[i]*v[i]/2.0; l[i] = 0.5; p[i] = 0.0; } // Конец цикла задания параметров частиц np+=kchsl; // Общее число частиц } // Конец цикла по слоям // ======================================================= // Начало расчета шага по времени // ======================================================= begcalc: dt = 0.033*nstp; // Увеличение dt до нормального за 30 шагов cout<<" SumSk "<<sumsk; w1 = kur/sumsk; if (dt>w1) dt=w1; if (dt*msk>delta) dt = delta/msk; if (kur>10.0) dt = kur/1000.0/tbez; sumsk = -975; msk = 0.0; kvisc = maxvisc; cout<<" D_T "<<dt<<" W1 "<<w1<<" msk "<<msk<<" kur "<<kur<<" np "<<np<<"\n"; // ------------------------------------------------------- // Расчет дивергенции для вязкости // ------------------------------------------------------- // Очистка сеточных массивов for (i=0; i<=ncr; i++) { c1[i] = 0; c2[i] = 0.0; c3[i] = 0.0; c4[i] = 0.0; } // Конец цикла очистки сеточных массивов // Цикл по частицам for ( i=1; i<=np; i++) { j = (int)(r[i]); // c1 - маркеры // с2 - сумма v*ro // c3 - сумма ro // c4 - итоговая скорость w1 = ro[i]; // Плотность w4 = v[i]*w1; // Плотность импульса // В плоском случае раздаем массы if (rad == 0) { w1 *= 2*l[i]; w4 *= 2*l[i]; } c1[j] = c1[j] | m[i]; c1[j+1] = c1[j+1] | m[i]; // Mаркировка ??? c2[j] += w4; c3[j] += w1; c2[j+1] += w4; c3[j+1] += w1; } // Конец цикла по частицам // ------------------------------------------------------- // Находим значения скорости // ------------------------------------------------------- for (j=0; j<=ncr; j++) {if (c3[j] != 0.0) c4[j] = c2[j]/c3[j];} // Закрытые границы - v=0 if (zgr1 == 1) c4[0] = 0.0; if (zgr2 == 1) c4[ncr] = 0.0; // Контактные границы ?? // Свободные границы ?? // ------------------------------------------------------- // Расчет силового этапа // ------------------------------------------------------- // Очистка сеточных массивов cout<<" Force "; for (i=0; i<=ncr; i++) { c2[i] = 0.0; c3[i] = 0.0; c5[i] = 0.0; } // Конец цикла очистки сеточных массивов // Цикл по частицам for ( i=1; i<=np; i++) { j = (int)(r[i]); es = e[i] - v[i]*v[i]/2.0; // Внутренняя энергия if (es<0.0) es = 0.0; ros = ro[i]; // Плотность w3 = eos(m[i], &nb[i], ros, es, &cs); //cout<<" eos "<<w3<<" ros "<<ros<<" es "<<es; vr = c4[j+1] - c4[j]; // Производная скорости w1 = fabs(vr); // Обрезание производной if (w1<eps) vr=0.0; w7 = -kvisc*vr*ro[i]*cs; // Искусственная вязкость w9 = fabs(v[i]); w5 = cs + (w9); // Макс. скорость сигнала if (sumsk<w5) sumsk = w5; if (msk<w9) msk = w9; w3 += (w7); // Давление + вязкость w10= 1/ro[i]; // Удельный объем частицы if (w3<pkr) w3 = pkr; // Ограничение отриц. давл. p[i] = w3; // Давление - в массив // c2 - сумма давлений // с3 - сумма удельных объемов // c5 - итоговое давление */ c2[j] += (w3*w10); c3[j] += (w10); c2[j+1] += (w3*w10); c3[j+1] += (w10); } // Конец цикла по частицам // ------------------------------------------------------- // Находим значения давления // ------------------------------------------------------- for (j=0; j<=ncr; j++) {if (c3[j] != 0) c5[j] = c2[j]/c3[j];} // Давление на св. гр. = 0 for (j=1; j<=ncr-1; j++) if (c3[j] == 0) {c5[j-1] = 0; c5[j+1] = 0;} // ------------------------------------------------------- // Расчет промежуточных скоростей // ------------------------------------------------------- // Очистка сеточных массивов for (i=0; i<=ncr; i++) { c2[i] = 0.0; c3[i] = 0.0; c4[i] = 0.0; } // Конец цикла очистки сеточных массивов // Цикл по частицам for ( i=1; i<=np; i++) { j = (int)(r[i]); // с2 - сумма v*ro // c3 - сумма ro // c4 - итоговая скорость */ fr = c5[j+1] - c5[j]; // Производная давления w1 = fabs(fr); // Обрезание производной if (w1<eps) fr=0.0; w9 = v[i] - fr*dt/ro[i]; // Новая скорость w1 = ro[i]; // Плотность w8 = (w9+v[i])/2.0; // Полусумма ст. и нов. скор. w4 = w8*w1; // Плотность импульса v[i] = w9; // Сохранили скорость // В плоском случае раздаем массы if (rad == 0) { w1 *= (2*l[i]); w4 *= (2*l[i]); } c2[j] += w4; c3[j] += w1; c2[j+1] += w4; c3[j+1] += w1; } // Конец цикла по частицам // ------------------------------------------------------- // Находим значения сеточных скоростей // ------------------------------------------------------- for (j=0; j<=ncr; j++) {if (c3[j] != 0) c4[j] = c2[j]/c3[j];} // Закрытые границы - v=0 if (zgr1 == 1) c4[0] = 0.0; if (zgr2 == 1) c4[ncr] = 0.0; // ------------------------------------------------------- // Расчет новых параметов частиц // ------------------------------------------------------- // Цикл по частицам for ( i=1; i<=np; i++) { j = (int)(r[i]); vr = c4[j+1] - c4[j]; // Производная скорости w1 = fabs(vr); // Обрезание производной if (w1<eps) vr=0.0; w9 = c5[j+1] * c4[j+1]; w10 = c5[j] * c4[j]; pvr = w9 - w10; // Производная pv для энергии w1 = fabs(pvr); // Обрезание производной if (w1<eps) pvr=0.0; // Дивергенция pv if (rad==1) pvr += (w9+w10)/r[i]/2.0; w6 = (c4[j+1]+c4[j])/2.0; // Скорость перемещения част. e[i] -= (pvr*dt/ro[i]); // Новая полная энергия // Старый объем w9 = l[i]; if (rad==1) w9 *= r[i]; l[i] *= (1+vr*dt); // Новый размер частицы rr = r[i]+(w6*dt); // Новая координата // Отношение стар. об. к нов. w9 /= l[i]; if (rad==1) w9 /= rr; ro[i] *= w9; // Новая плотность r[i] = rr; // Занесение координаты // ------------------------------------------------------- // Взаимодействие с границами поля // ------------------------------------------------------- if (j==0) { // Граница R = 0 w2 = rr-l[i]; // Нижняя граница частицы i1or=(w2<-krdr) ? 1 : 0; if (i1or) { // Перехлест ! if (zgr1==1) { // Действия при закрытой границе v[i] = 0.0; // Частица останавливается } // Конец закрытой границы R = 0 } // Конец перехлеста } // Конец границы R = 0 if ((j+1)==ncr) { // Граница R = ncr w2 = rr+l[i]; // Верхняя граница частицы if ((w2-ncr)>krdr) { // Перехлест ! if (zgr1==1) { // Действия при закрытой границе v[i] = 0.0; // Частица останавливается } // Конец закрытой границы R = ncr } // Конец перехлеста } // Конец границы R = ncr } // Конец цикла по частицам // ------------------------------------------------------- // Этап дробления частиц // ------------------------------------------------------- ii = part; // Дно массивов частиц kolp = 0; // Счетчик числа новых частиц // Цикл по частицам for ( i=np; i>=1; i--) { // Начиная с последней к началу j = (int)(r[i]); w1 = r[i] - l[i]; // R нижняя w2 = r[i] + l[i]; // R верхняя // Есть ли дробление вверх w4 = w2 -(j+1); // Часть в верхней ячейке if (w4>krdr) { // Дробление вверх - перепись и правка m[ii]=m[i]; nb[ii]=nb[i]; v[ii]=v[i]; ro[ii]=ro[i]; e[ii]=e[i]; l[ii]=w4/2.0; r[ii]=w2-l[ii]; w2 = j+1; // Верхний радиус коренной ii--; kolp++;} // Конец дробления вверх // Есть ли дробление вниз w4 = j - w1; drob = w4>krdr ? 1 : 0; // Перепись коренной частицы m[ii]=m[i]; nb[ii]=nb[i]; v[ii]=v[i]; ro[ii]=ro[i]; e[ii]=e[i]; w5 = drob==1 ? j : w1; l[ii]=(w2-w5)/2.0; r[ii]=w2-l[ii]; ii--; kolp++; // Конец правки коренной if (drob==1) {// Дробление вниз - перепись и правка m[ii]=m[i]; nb[ii]=nb[i]; v[ii]=v[i]; ro[ii]=ro[i]; e[ii]=e[i]; l[ii]=(j-w1)/2.0; r[ii]=j-l[ii]; ii--; kolp++;} // Конец дробления вниз } // Конец цикла по частицам cout<<" Order "; // ------------------------------------------------------- // Здесь может быть цикл по упорядочиванию частиц ??? // ------------------------------------------------------- // ------------------------------------------------------- // Этап объединения частиц // ------------------------------------------------------- k = 1; // Начало объединенных частиц i = ii+1; // Начало раздробленнных ч. // Цикл по частицам loopp: if (i>part) goto endloopp; // Переписываем очередную m[k]=m[i]; nb[k]=nb[i]; v[k]=v[i]; ro[k]=ro[i]; e[k]=e[i]; l[k]=l[i]; r[k]=r[i]; j = (int)(r[i]); // Левый узел i1 = m[i]; // Маркер sled:i++; j1 = (int)(r[i]); i2 = m[i]; if ((j==j1) && (i1==i2)) { // Объединение // Массы частиц w3 = 2*ro[k]*l[k]; w4 = 2*ro[i]*l[i]; if (rad==1) {w3*=(2*PI*r[k]); w4*=(2*PI*r[i]);} w5 = w3 + w4; // Суммарная масса // Параметры объединения r[k] = (r[k]+r[i]-l[k]+l[i])/2.0; ro[k] = w5/(w3/ro[k]+w4/ro[i]); v[k] = (w3*v[k]+w4*v[i])/w5; e[k] = (w3*e[k]+w4*e[i])/w5; l[k] += l[i]; goto sled; } // Конец объединения k++; goto loopp; endloopp: np = k-1; // Очистка оставшейся части массивов for (i=k; i<=part; i++) { m[i] = 0; nb[i] = 0; r[i] = 0.0; v[i] = 0.0; ro[i] = 0.0; e[i] = 0.0; l[i] = 0.0; p[i] = 0.0; } // Конец очистки параметров частиц t += dt; nstp++; izap++; cout<<" Compare to write? nstp "<<nstp<<" izap "<<izap; if (nstp==1) { // Открываем файл для записи таблиц {char tmp[256];SetExt(namezad,tmp,"t");}//ii = open(tmp, O_CREAT,S_IWRITE); ii=OP_F(namezad, ".t", 1); if (ii<0) { cout<<"Нельзя открыть файл <.t> на запись ! "<<ii<<"\n";exit(1);}} if ((nstp==1)||(izap==stzap)) { // Запись результатов на диск if (izap==stzap) {izap=0; nzap++;} // ------------------------------------------------------- // Массивы для высвечивания // ------------------------------------------------------- // Очистка сеточных массивов for (i=0; i<=ncr; i++) { c1[i] = 0; c2[i] = 0.0; c3[i] = 0.0; c4[i] = 0.0; c5[i] = 0.0; } // Конец цикла очистки сеточных массивов massa=0.0000001; impulse=1.0000001; energy=1.0000001; // Цикл по частицам for ( i=1; i<=np; i++) { j = (int)(r[i]); //c1 - вес //с2 - плотность //c3 - давление //с4 - скорость //c5 - внутренняя энергия c1[j]++; c1[j+1]++; c2[j] += ro[i]; c2[j+1] += ro[i]; c3[j] += p[i]; c3[j+1] += p[i]; c4[j] += v[i]; c4[j+1] += v[i]; c5[j] += e[i]-v[i]*v[i]/2.0; c5[j+1] += e[i]-v[i]*v[i]/2.0; // Сохранение q = (rad==0) ? 2 : 4*PI*r[i]; i1or=(markt==0) ? 1 : 0; i2or=(markt==m[i]) ? 1 : 0; if (i1or || i2or) { massa += (q*l[i]*ro[i]); impulse += (massa*v[i]); energy += (massa*e[i]); } // Подсчета сохранения } // Конец цикла по частицам // ------------------------------------------------------- // Находим значения параметров // ------------------------------------------------------- for (j=0; j<=ncr; j++) { if (c1[j] != 0) { c2[j] =robez*c2[j]/c1[j]; c3[j] = pbez*c3[j]/c1[j]; c4[j] = vbez*c4[j]/c1[j]; c5[j] = ebez*c5[j]/c1[j]; }} // Закрытые границы - v=0 if (zgr1 == 1) c4[0] = 0.0; if (zgr2 == 1) c4[ncr] = 0.0; // Свободные границы-p=0 for (j=1; j<ncr; j++) { if (c1[j] == 0) { c3[j-1] = 0.0; c3[j+1] = 0.0; } } // Конец цикла поиска свободных границ w1=t*tbez; size=sizeof(nzap); fwrite(&nzap, size, 1, stream); fwrite(&nstp, size, 1, stream); fwrite(&ncr, size, 1, stream); fwrite(&markt, size, 1, stream); ii=ncr+1; size=sizeof(t); fwrite(&w1, size, 1, stream); fwrite(&dlina, size, 1, stream); fwrite(&massa, size, 1, stream); fwrite(&impulse, size, 1, stream); fwrite(&energy, size, 1, stream); fwrite(&c2, size, ii, stream); fwrite(&c3, size, ii, stream); fwrite(&c4, size, ii, stream); fwrite(&c5, size, ii, stream); printf(" Запись %d Step = %d t(mks) = %f dt(mks) = %f\n",nzap,nstp,t*tbez,dt*tbez); //pause(); } // Конец записи результатов на диск // ------------------------------------------------------- // Шаг по времени завершен // ------------------------------------------------------- if ((i=kbhit())!=0) { printf("\n Пауза...\n Задача *%s* Step = %d t(mks) = %f dt(mks) = %f\n", namezad,nstp,t*tbez,dt*tbez); ii=pause(); if (ii==1) { fclose(stream);exit(0);}} // КОНЕЦ РАБОТЫ if (nstp==ststp) { fclose(stream); exit(0);} // KОНЕЦ РАБОТЫ cout<<" After write ? goto BegCalc \n"; goto begcalc; } // Конец MAIN - программы ==================================