#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 - программы ==================================
