void block::reloop(int &idep, int &idepmax, particle *list, neighbor *nblist, force *firr, force *freg, const double &eta) {
if (idep<idepmax&&flag[idep][1]) {
reloop(++idep,idepmax,list,nblist,firr,freg,eta);
}
else {
if (blocks[idep].ntot) {
for (int i=0; i<blocks[idep].ntot; i++) {
int index=blocks[idep].now;
force_corr fcorr;
step_forward(list[index],nblist[index],list,firr[index],freg[index],fcorr,dtlist[idep]);
int newdep=locate(time_pred(eta,&fcorr),dtlist[0]);
if (newdep>idep&&newdep<depth) {
move(idep,newdep);
if (newdep>idepmax) idepmax=newdep;
}
else if(newdep<idep&&!flag[idep][0]) move(idep,newdep);
else if(newdep>=depth) {
std::cerr<<"Small time step "<<dt<<" for "<<pindex<<std::endl;
exit(0);
}
blocks[idep].next();
}
}
flag[idep][0]=!flag[idep][0];
if (flag[idep][0]) flag[idep][1]=1;
else {
flag[idep][1]=1;
if (--idep<0) return;
flag[idep][1]=0;
}
reloop(idep,idepmax,list,nblist,firr,freg,eta);
}
}
int n_steps (struct world *world, int delta)
{
int i;
int display_incrementally;
int ret, ret2;
if (abs (delta) < 10) {
display_incrementally = 1;
} else {
display_incrementally = 0;
}
if (delta<0) {
for (i=0;i>delta;i--) {
if ((ret=step_backward (world, display_incrementally)) != 0) break;
}
} else {
for (i=0;i<delta;i++) {
if ((ret=step_forward (world, display_incrementally)) != 0) break;
}
}
if (!display_incrementally) {
if ((ret2=update_everything (world))!=0) return ret2;
}
return ret;
}
void SCL::run()
{
std::cout.precision(6);
std::cout.setf(std::ios::scientific, std::ios::floatfield);
double start_time = MPI_Wtime();
double last_time = start_time;
double this_time;
initialize();
do {
step_forward();
adapt_mesh();
load_balance(); /// 完成负载平衡
getControl();
if (htree.rank() == 0) {
last_time = this_time;
this_time = MPI_Wtime();
std::cout << "t = " << t
<< ", dt = " << dt
<< ", wall time = " << this_time - start_time
<< ", step time = " << this_time - last_time
<< std::endl;
}
} while(end_t - t > 2.0e-16);
}
/* A round forward. If display is non-zero the display is updated. */
int round_forward (struct world *world, int display)
{
int ret;
if ((ret=skip_round_markers (world, 1))!=0) return ret;
while (world->cursor && world->cursor->ant) {
if ((ret=step_forward (world, display))!=0) return ret;
}
return 0;
}
void CQPlayerControlWidget::slot_step_forward_clicked()
{
if (this->mCurrentStep != this->mNumSteps - 1)
{
++this->mCurrentStep;
}
this->updateButtons();
this->updateActions();
emit step_forward();
}
void glut_key_action(unsigned char key, int x, int y)
{
switch (key) {
case 'q':
case 27:
exit(0);
case 's':
save_image(-1);
break;
case 'r':
recording ^= 1;
if (recording)
printf("Recording ON\n");
else
printf("Recording OFF\n");
break;
case ',':
case '+':
animating = 0;
step_forward();
break;
case '.':
case '-':
animating = 0;
step_back();
break;
case ' ':
animating = !animating;
break;
case '<':
animating = 1;
dt = -tStep;
break;
case '>':
animating = 1;
dt = tStep;
break;
}
}
static void do_move(t_world *world)
{
if (world->rotate_up)
rotate_up(world);
if (world->rotate_down)
rotate_down(world);
if (world->rotate_left)
rotate_left(world);
if (world->rotate_right)
rotate_right(world);
if (world->move_down)
world->position->y -= 1;
if (world->move_up)
world->position->y += 1;
if (world->move_forward)
step_forward(world);
if (world->move_left)
step_left(world);
if (world->move_backward)
step_backward(world);
if (world->move_right)
step_right(world);
}
int
main(int argc, char** argv)
{
bool verb, fsrf, snap, expl, dabc, cden, adj;
bool optfd, hybrid, sinc;
int jsnap, jdata;
/* I/O files */
sf_file file_wav=NULL; /* wavelet */
sf_file file_vel=NULL; /* velocity */
sf_file file_den=NULL; /* density */
sf_file file_wfl=NULL; /* wavefield */
sf_file file_dat=NULL; /* data */
sf_file file_src=NULL; /* sources */
sf_file file_rec=NULL; /* receivers */
/* cube axes */
sf_axis at = NULL, az = NULL, ax = NULL, ay = NULL;
sf_axis as = NULL, ar = NULL;
int nbd; /* ABC boundary size */
int fdorder; /* finite difference spatial accuracy order */
int nzpad,nxpad,nypad; /* boundary padded model size */
int ix,iy,it,is,nx,ny,nz,nt,ns,nr;
float dx,dy,dz,dt,dt2;
float* damp=NULL; /* damping profile for hybrid bc */
float* ws; /* wavelet */
float*** vel=NULL; /* velocity */
float*** rho=NULL; /* density */
float*** u0=NULL; /* wavefield array u@t-1 (u@t+1) */
float*** u1=NULL; /* wavefield array u@t */
float* u_dat=NULL; /* output data */
float*** ptr_tmp=NULL;
pt3d* src3d=NULL; /* source position */
pt3d* rec3d=NULL; /*receiver position*/
scoef3d cssinc = NULL, crsinc = NULL;
lint3d cslint = NULL, crlint = NULL;
/* FDM structure */
fdm3d fdm = NULL;
abcone3d abc = NULL;
sponge spo = NULL;
int nbell;
float* fdcoef_d2;
float* fdcoef_d1;
sf_axis acz = NULL, acx = NULL, acy = NULL;
int nqz, nqx, nqy;
float oqz, oqx, oqy, dqz, dqx, dqy;
float** oslice = NULL; /* output 3D wavefield slice-by-slice */
float*** tmp_array;
double wall_clock_time_s, wall_clock_time_e;
const int SECOND_DERIV = 2;
const int FIRST_DERIV = 1;
int nop;
#if defined _OPENMP && _DEBUG
double tic;
double toc;
#endif
/* init RSF */
sf_init(argc,argv);
#ifdef _OPENMP
omp_init();
wall_clock_time_s = omp_get_wtime();
#else
wall_clock_time_s = (double) clock() / CLOCKS_PER_SEC;
#endif
if (!sf_getbool("verb",&verb)) verb=false; /* Verbosity flag */
if (!sf_getbool("snap",&snap)) snap=false; /* Wavefield snapshots flag */
if (!sf_getbool("expl",&expl)) expl=false; /* Multiple sources, one wvlt*/
if (!sf_getbool("dabc",&dabc)) dabc=false; /* Absorbing BC */
if (!sf_getbool("cden",&cden)) cden=false; /* Constant density */
if (!sf_getbool("adj",&adj)) adj=false; /* adjoint flag */
if (!sf_getbool("free",&fsrf) && !sf_getbool("fsrf",&fsrf)) fsrf=false; /* Free surface flag */
if (!sf_getint("nbell",&nbell)) nbell=5; /* gaussian for source injection */
if (!sf_getbool("optfd",&optfd)) optfd=false; /* optimized FD coefficients flag */
if (!sf_getint("fdorder",&fdorder)) fdorder=4; /* spatial FD order */
if (!sf_getbool("hybridbc",&hybrid)) hybrid=false; /* hybrid Absorbing BC */
if (!sf_getbool("sinc",&sinc)) sinc=false; /* sinc source injection */
/* Initialize variables */
file_wav = sf_input("in"); /* wavelet */
file_vel = sf_input("vel"); /* velocity */
file_src = sf_input("sou"); /* sources */
file_rec = sf_input("rec"); /* receivers */
file_dat = sf_output("out"); /* data */
if (snap) file_wfl = sf_output("wfl"); /* wavefield */
if (!cden) {
if (sf_getstring("cden")) {
file_den = sf_input ("den"); /* density */
} else {
cden = true;
if (verb) sf_warning("No density file provided, running with constant density");
}
}
at = sf_iaxa(file_wav,2); sf_setlabel(at,"t"); if(verb) sf_raxa(at); /* time */
az = sf_iaxa(file_vel,1); sf_setlabel(az,"z"); if(verb) sf_raxa(az); /* depth */
ax = sf_iaxa(file_vel,2); sf_setlabel(ax,"x"); if(verb) sf_raxa(ax); /* space */
ay = sf_iaxa(file_vel,3); sf_setlabel(ay,"y"); if(verb) sf_raxa(ay); /* space */
as = sf_iaxa(file_src,2); sf_setlabel(as,"s"); if(verb) sf_raxa(as); /* sources */
ar = sf_iaxa(file_rec,2); sf_setlabel(ar,"r"); if(verb) sf_raxa(ar); /* receivers */
nt = sf_n(at); dt = sf_d(at);
nz = sf_n(az); dz = sf_d(az);
nx = sf_n(ax); dx = sf_d(ax);
ny = sf_n(ay); dy = sf_d(ay);
ns = sf_n(as);
nr = sf_n(ar);
/* other execution parameters */
if (snap) {
if (!sf_getint("jsnap",&jsnap)) jsnap=nt;
/* # of t steps at which to save wavefield */
}
if (!sf_getint("jdata",&jdata)) jdata=1;
/* # of t steps at which to save receiver data */
/* setup output data header */
sf_oaxa(file_dat,ar,1);
sf_setn(at,(nt-1)/jdata+1);
sf_setd(at,dt*jdata);
sf_oaxa(file_dat,at,2);
/* wavefield cut params */
/* setup output wavefield header */
if (snap) {
if (!sf_getint ("nqz",&nqz)) nqz=sf_n(az); /* Saved wfld window nz */
if (!sf_getint ("nqx",&nqx)) nqx=sf_n(ax); /* Saved wfld window nx */
if (!sf_getint ("nqy",&nqy)) nqy=sf_n(ay); /* Saved wfld window ny */
if (!sf_getfloat("oqz",&oqz)) oqz=sf_o(az); /* Saved wfld window oz */
if (!sf_getfloat("oqx",&oqx)) oqx=sf_o(ax); /* Saved wfld window ox */
if (!sf_getfloat("oqy",&oqy)) oqy=sf_o(ay); /* Saved wfld window oy */
if (!sf_getfloat("dqz",&dqz)) dqz=sf_d(az); /* Saved wfld window dz */
if (!sf_getfloat("dqx",&dqx)) dqx=sf_d(ax); /* Saved wfld window dx */
if (!sf_getfloat("dqy",&dqy)) dqy=sf_d(ay); /* Saved wfld window dy */
acz = sf_maxa(nqz,oqz,dqz); if (verb) sf_raxa(acz);
acx = sf_maxa(nqx,oqx,dqx); if (verb) sf_raxa(acx);
acy = sf_maxa(nqy,oqy,dqy); if (verb) sf_raxa(acy);
/* check if the imaging window fits in the wavefield domain */
sf_setn(at,(nt-1)/jsnap+1);
sf_setd(at,dt*jsnap);
if (verb) sf_raxa(at);
sf_oaxa(file_wfl,acz,1);
sf_oaxa(file_wfl,acx,2);
sf_oaxa(file_wfl,acy,3);
sf_oaxa(file_wfl,at,4);
}
/* 2-2N finite difference coefficient */
nop = fdorder/2; /* fd half-length stencil */
if (!sf_getint("nb",&nbd) || nbd<nop) nbd=nop;
if (dabc && hybrid && nbd<=nop) nbd = 2*nop;
/* expand domain for FD operators and ABC */
fdm = fdutil3d_init(verb,fsrf,az,ax,ay,nbd,1);
sf_setn(az,fdm->nzpad); sf_seto(az,fdm->ozpad); if (verb) sf_raxa(az);
sf_setn(ax,fdm->nxpad); sf_seto(ax,fdm->oxpad); if (verb) sf_raxa(ax);
sf_setn(ay,fdm->nypad); sf_seto(ay,fdm->oypad); if (verb) sf_raxa(ay);
/* Precompute coefficients */
dt2 = dt*dt;
nzpad = nz+2*nbd; nxpad = nx+2*nbd; nypad = ny+2*nbd;
fdcoef_d2 = compute_fdcoef(nop,dz,dx,dy,optfd,SECOND_DERIV);
fdcoef_d1 = compute_fdcoef(nop,dz,dx,dy,optfd,FIRST_DERIV);
/* Allocate memories */
if (expl) ws = sf_floatalloc(1);
else ws = sf_floatalloc(ns);
vel = sf_floatalloc3(nzpad,nxpad,nypad);
if (!cden) rho = sf_floatalloc3(nzpad,nxpad,nypad);
u_dat = sf_floatalloc(nr);
src3d = pt3dalloc1(ns);
rec3d = pt3dalloc1(nr);
if (snap) oslice = sf_floatalloc2(sf_n(acz),sf_n(acx));
/* source and receiver position */
pt3dread1(file_src,src3d,ns,3); /* read format: (x,y,z) */
if (sinc) cssinc = sinc3d_make(ns,src3d,fdm);
else cslint = lint3d_make(ns,src3d,fdm);
pt3dread1(file_rec,rec3d,nr,3); /* read format: (x,y,z) */
if (sinc) crsinc = sinc3d_make(nr,rec3d,fdm);
else crlint = lint3d_make(nr,rec3d,fdm);
if (!sinc) fdbell3d_init(nbell);
/* temperary array */
tmp_array = sf_floatalloc3(nz,nx,ny);
/* read velocity and pad */
sf_floatread(tmp_array[0][0],nz*nx*ny,file_vel);
expand3d(tmp_array,vel,fdm);
/* read density and pad */
if (!cden) {
sf_floatread(tmp_array[0][0],nz*nx*ny,file_den);
expand3d(tmp_array,rho,fdm);
}
free(**tmp_array); free(*tmp_array); free(tmp_array);
/* A1 one-way ABC implicit scheme coefficients */
if (dabc) {
abc = abcone3d_make(nbd,dt,vel,fsrf,fdm);
if (hybrid)
damp = damp_make(nbd-nop); /* compute damping profiles for hybrid bc */
else
spo = sponge_make(fdm->nb);
}
/* allocate memory for wavefield variables */
u0 = sf_floatalloc3(nzpad,nxpad,nypad);
u1 = sf_floatalloc3(nzpad,nxpad,nypad);
/* initialize variables */
memset(u0[0][0],0,sizeof(float)*nzpad*nxpad*nypad);
memset(u1[0][0],0,sizeof(float)*nzpad*nxpad*nypad);
memset(u_dat,0,sizeof(float)*nr);
/* v = (v*dt)^2 */
for (ix=0;ix<nzpad*nxpad*nypad;ix++)
*(vel[0][0]+ix) *= *(vel[0][0]+ix)*dt2;
if (fsrf && !hybrid) {
for (iy=0; iy<nypad; iy++)
for (ix=0; ix<nxpad; ix++)
memset(vel[iy][ix],0,sizeof(float)*fdm->nb);
}
for (it=0; it<nt; it++) {
if (verb) sf_warning("it=%d;",it+1);
#if defined _OPENMP && _DEBUG
tic=omp_get_wtime();
#endif
step_forward(u0,u1,vel,rho,fdcoef_d2,fdcoef_d1,nop,nzpad,nxpad,nypad);
if (adj) { /* backward inject source wavelet */
if (expl) {
sf_seek(file_wav,(off_t)(nt-it-1)*sizeof(float),SEEK_SET);
sf_floatread(ws,1,file_wav);
ws[0] *= dt2;
if (sinc) sinc3d_inject1(u0,ws[0],cssinc);
else lint3d_inject1(u0,ws[0],cslint);
} else {
sf_seek(file_wav,(off_t)(nt-it-1)*ns*sizeof(float),SEEK_SET);
sf_floatread(ws,ns,file_wav);
for (is=0; is<ns; is++) ws[is] *= dt2;
if (sinc) sinc3d_inject(u0,ws,cssinc);
else lint3d_inject(u0,ws,cslint);
}
} else { /* forward inject source wavelet */
if (expl) {
sf_floatread(ws,1,file_wav);
ws[0] *= dt2;
if (sinc) sinc3d_inject1(u0,ws[0],cssinc);
else lint3d_inject1(u0,ws[0],cslint);
} else {
sf_floatread(ws,ns,file_wav);
for (is=0; is<ns; is++) ws[is] *= dt2;
if (sinc) sinc3d_inject(u0,ws,cssinc);
else lint3d_inject(u0,ws,cslint);
}
}
/* apply abc */
if (dabc) {
if (hybrid) apply_abc(u0,u1,nz,nx,ny,nbd,abc,nop,damp);
else {
abcone3d_apply(u0,u1,nop,abc,fdm);
sponge3d_apply(u0,spo,fdm);
sponge3d_apply(u1,spo,fdm);
}
}
/* loop over pointers */
ptr_tmp = u0; u0 = u1; u1 = ptr_tmp;
/* extract snapshot */
if (snap && it%jsnap==0) {
int fy = (floor)((sf_o(acy)-fdm->oypad)/fdm->dy);
int jy = floor(sf_d(acy)/fdm->dy);
float **ptr_slice;
for (iy=0; iy<sf_n(acy); iy++) {
ptr_slice = u0[fy+iy*jy];
cut3d_slice(ptr_slice,oslice,fdm,acz,acx);
sf_floatwrite(oslice[0],sf_n(acz)*sf_n(acx),file_wfl);
}
}
/* extract receiver data */
if (sinc) sinc3d_extract(u0,u_dat,crsinc);
else lint3d_extract(u0,u_dat,crlint);
sf_floatwrite(u_dat,nr,file_dat);
#if defined _OPENMP && _DEBUG
toc=omp_get_wtime();
fprintf(stderr,"%5.2gs",(float)(toc-tic));
#endif
}
#ifdef _OPENMP
wall_clock_time_e = omp_get_wtime();
#else
wall_clock_time_e = (double) clock() / CLOCKS_PER_SEC;
#endif
if (verb)
fprintf(stderr,"\nElapsed time: %lf s\n",wall_clock_time_e-wall_clock_time_s);
free(**u0); free(*u0); free(u0);
free(**u1); free(*u1); free(u1);
free(**vel); free(*vel); free(vel);
free(u_dat);
free(ws);
free(fdcoef_d2); free(fdcoef_d1);
if (snap) { free(*oslice); free(oslice); }
if(!cden) { free(**rho); free(*rho); free(rho); }
if (hybrid) free(damp);
free(src3d); free(rec3d);
return 0;
}
int main(int argc, char ** argv) {
/* BEGIN DECLARATIONS */
WINFO wi; /* struct for command line input */
/* workspace */
float * v; /* velocity field */
float * p1; /* pressure field, current time step */
float * p0; /* pressure field, last time step */
float * tr; /* storage for traces */
float * tmp; /* used to swap p1 and p0 */
int ix, it; /* counters */
int isrc; /* source counter */
int imf; /* movie frame counter */
int isx; /* source location, in units of dx */
int nxz; /* number of spatial grid points */
/* int nz; local number of gridpoints */
int ntr; /* number of traces */
int nsam; /* number of trace samples */
int nsrc; /* number of shots */
float rz,rx,s; /* precomputed coefficients */
float vmax,vmin; /* max, min velocity values */
/* float two; two */
/* END DECLARATIONS */
sf_init(argc,argv);
/* read inputs from command line */
getinputs(true,&wi);
/* compute number of shots */
nsrc = (wi.isxend-wi.isxbeg)/(wi.iskip); nsrc++;
/* compute number of spatial grid points */
nxz=wi.nx * wi.nz;
/* compute number of traces, samples in each record */
ntr=wi.igxend-wi.igxbeg+1;
nsam=ntr*wi.nt;
/* allocate, initialize p0, p1, v, traces */
p0=sf_floatalloc(nxz);
p1=sf_floatalloc(nxz);
v =sf_floatalloc(nxz);
tr=sf_floatalloc(nsam);
/* read velocity */
sf_floatread(v,nxz,wi.vfile);
/* CFL, sanity checks */
vmax=fgetmax(v,nxz);
vmin=fgetmin(v,nxz);
if (vmax*wi.dt>CFL*fmaxf(wi.dx,wi.dz)) {
sf_warning("CFL criterion violated");
sf_warning("vmax=%e dx=%e dz=%e dt=%e\n",vmax,wi.dx,wi.dz,wi.dt);
sf_error("max permitted dt=%e\n",CFL*fmaxf(wi.dx,wi.dz)/vmax);
}
if (vmin<=0.0)
sf_error("min velocity nonpositive");
/* only square of velocity array needed from here on */
fsquare(v,nxz);
/* precalculate some coefficients */
rz=wi.dt*wi.dt/(wi.dz*wi.dz);
rx=wi.dt*wi.dt/(wi.dx*wi.dx);
s =2.0*(rz+rx);
/* two=2.0;
nz=wi.nz; */
/* shot loop */
isrc=0;
isx=wi.isxbeg;
while (isx <= wi.isxend) {
/* initialize pressure fields, traces */
fzeros(p0,nxz);
fzeros(p1,nxz);
fzeros(tr,nsam);
/* initialize movie frame counter */
imf=0;
/* time loop */
for (it=0;it<wi.nt;it++) {
/* construct next time step, overwrite on p0 */
step_forward(p0,p1,v,wi.nz,wi.nx,rz,rx,s);
/* tack on source */
p0[wi.isz+isx*wi.nz]+=fgetrick(it*wi.dt,wi.freq);
/* swap pointers */
tmp=p0;
p0=p1;
p1=tmp;
/* store trace samples if necessary */
if (NULL != wi.tfile)
for (ix=0;ix<ntr;ix++)
tr[ix*wi.nt+it]=p1[(wi.igxbeg+ix)*wi.nz+wi.igz];
/* write movie snap to file if necessary */
if (NULL != wi.mfile && wi.nm && !(it%wi.nm)) {
sf_floatwrite(p1,nxz,wi.mfile);
imf++;
}
/* next t */
}
/* write traces to file if necessary */
if (NULL != wi.tfile)
sf_floatwrite(tr,nsam,wi.tfile);
isx += wi.iskip;
isrc++;
}
exit(0);
}
int main(int argc, char* argv[])
{
if (argc != 2)
{
printf("Bad argument! Just give me a filename of a compiled assembly program.\n");
return -EINVAL;
}
enable_udiv = 1;
FILE* program;
if (!(program = fopen(argv[1], "r")))
{
printf("Bad argument! File not found.\n");
return -EINVAL;
}
build_symbol_table(argv[1]);
pc = 0x3000;
running = 1;
read_program(program);
int ch;
initialize();
while(ch != KEY_F(1))
{
ch = getch();
switch (ch) {
case KEY_F(2):
reset_program(program);
break;
case KEY_F(3):
dbgwin_state = 1;
break;
case KEY_F(4):
break;
case KEY_F(5):
step_forward();
break;
case KEY_F(6):
run_program();
break;
case KEY_F(7):
memwin_state = (memwin_state == 2 ? 0 : 2);
mem_cursor = mem_index;
break;
case KEY_F(8):
dbgwin_state = 2;
break;
case KEY_UP:
if (memwin_state == 2)
mem_cursor--;
break;
case KEY_DOWN:
if (memwin_state == 2)
mem_cursor++;
break;
case KEY_NPAGE:
if (memwin_state == 2)
mem_cursor += (LINES-DEBUGWIN_HEIGHT);
break;
case KEY_PPAGE:
if (memwin_state == 2)
mem_cursor -= (LINES-DEBUGWIN_HEIGHT);
break;
case 0xA:
if (memwin_state ==2)
brk[(unsigned short)mem_cursor] ^= 1;
break;
}
refreshall();
}
quit:
curs_set(1);
endwin();
return 0;
}
/**
* Hauptfunktion. Wird als erstes aufgerufen.
* Struktogramm:
* <img src="../../Spielablauf_Struktogramm.png">
* @return gibt 0 zurück
*/
int main()
{
init_graphics(); //Function um Grafik Lib zu initialisieren, gibt evtl später mal Errorcode zurück...
init_counter();
/**
* \todo UART Interrupts funktionieren noch nicht.
* Als Workaround wird nun alle 1ms im Timer-Interrupt-Handler die UART1 Schnittstelle gepollt. <br>
*/
init_uart();
init_genrand(GUI_GetTime());
while(1)
{
init_game();
init_level();
// warten bis eine taste gedrückt wird, welche den initialen Zustand von snake_direction ändert
snake_direction = '?';
while(snake_direction == '?');
// jetzt food zeichnen
food = randomize_food();
draw_food(food);
enable_interrupts();
do
{
switch(step_forward(check_initial_state()))
{
case COLLISION:
game_over = 1;
disable_interrupts();
//write_byte(score);
FFLCR &= ~(1<<7); // DLAB löschen für zugriff
while (!(FFLSR & (1<<5))); // Solange UART Busy
FFTHR = score;
enable_interrupts();
break;
case FOOD:
score++;
if(size >= 15)
{
// wenn Länge = 15: Level-Up
score += 10;
level++;
init_level();
}
food = randomize_food();
disable_interrupts();
draw_food(food);
enable_interrupts();
break;
case NOTHING:
break;
}
delay(delay_time);
}
while(game_over != 1);
}
return 0;
}
char *
readline(const char *prompt)
{
int cur_char;
char *new_line;
/* start with a string of MAXBUF chars */
if (line_len != 0) {
free(cur_line);
line_len = 0;
}
cur_line = gp_alloc(MAXBUF, "readline");
line_len = MAXBUF;
/* set the termio so we can do our own input processing */
set_termio();
/* print the prompt */
fputs(prompt, stderr);
cur_line[0] = '\0';
cur_pos = 0;
max_pos = 0;
cur_entry = NULL;
/* get characters */
for (;;) {
cur_char = special_getc();
/* Accumulate ascii (7bit) printable characters
* and all leading 8bit characters.
*/
if ((isprint(cur_char)
|| (((cur_char & 0x80) != 0) && (cur_char != EOF)))
&& (cur_char != 0x09) /* TAB is a printable character in some locales */
) {
size_t i;
if (max_pos + 1 >= line_len) {
extend_cur_line();
}
for (i = max_pos; i > cur_pos; i--) {
cur_line[i] = cur_line[i - 1];
}
user_putc(cur_char);
cur_line[cur_pos] = cur_char;
cur_pos += 1;
max_pos += 1;
cur_line[max_pos] = '\0';
if (cur_pos < max_pos) {
switch (encoding) {
case S_ENC_UTF8:
if ((cur_char & 0xc0) == 0)
fix_line(); /* Normal ascii character */
else if ((cur_char & 0xc0) == 0xc0)
; /* start of a multibyte sequence. */
else if (((cur_char & 0xc0) == 0x80) &&
((unsigned char)(cur_line[cur_pos-2]) >= 0xe0))
; /* second byte of a >2 byte sequence */
else {
/* Last char of multi-byte sequence */
fix_line();
}
break;
default:
fix_line();
break;
}
}
/* else interpret unix terminal driver characters */
#ifdef VERASE
} else if (cur_char == term_chars[VERASE]) { /* ^H */
delete_backward();
#endif /* VERASE */
#ifdef VEOF
} else if (cur_char == term_chars[VEOF]) { /* ^D? */
if (max_pos == 0) {
reset_termio();
return ((char *) NULL);
}
delete_forward();
#endif /* VEOF */
#ifdef VKILL
} else if (cur_char == term_chars[VKILL]) { /* ^U? */
clear_line(prompt);
#endif /* VKILL */
#ifdef VWERASE
} else if (cur_char == term_chars[VWERASE]) { /* ^W? */
delete_previous_word();
#endif /* VWERASE */
#ifdef VREPRINT
} else if (cur_char == term_chars[VREPRINT]) { /* ^R? */
putc(NEWLINE, stderr); /* go to a fresh line */
redraw_line(prompt);
#endif /* VREPRINT */
#ifdef VSUSP
} else if (cur_char == term_chars[VSUSP]) {
reset_termio();
kill(0, SIGTSTP);
/* process stops here */
set_termio();
/* print the prompt */
redraw_line(prompt);
#endif /* VSUSP */
} else {
/* do normal editing commands */
/* some of these are also done above */
switch (cur_char) {
case EOF:
reset_termio();
return ((char *) NULL);
case 001: /* ^A */
while (cur_pos > 0)
backspace();
break;
case 002: /* ^B */
if (cur_pos > 0)
backspace();
break;
case 005: /* ^E */
while (cur_pos < max_pos) {
user_putc(cur_line[cur_pos]);
cur_pos += 1;
}
break;
case 006: /* ^F */
if (cur_pos < max_pos) {
step_forward();
}
break;
#if defined(HAVE_DIRENT_H) || defined(WIN32)
case 011: /* ^I / TAB */
tab_completion(TRUE); /* next tab completion */
break;
case 034: /* remapped by wtext.c or ansi_getc from Shift-Tab */
tab_completion(FALSE); /* previous tab completion */
break;
#endif
case 013: /* ^K */
clear_eoline(prompt);
max_pos = cur_pos;
break;
case 020: /* ^P */
if (history != NULL) {
if (cur_entry == NULL) {
cur_entry = history;
clear_line(prompt);
copy_line(cur_entry->line);
} else if (cur_entry->prev != NULL) {
cur_entry = cur_entry->prev;
clear_line(prompt);
copy_line(cur_entry->line);
}
}
break;
case 016: /* ^N */
if (cur_entry != NULL) {
cur_entry = cur_entry->next;
clear_line(prompt);
if (cur_entry != NULL)
copy_line(cur_entry->line);
else
cur_pos = max_pos = 0;
}
break;
case 014: /* ^L */
case 022: /* ^R */
putc(NEWLINE, stderr); /* go to a fresh line */
redraw_line(prompt);
break;
#ifndef DEL_ERASES_CURRENT_CHAR
case 0177: /* DEL */
case 023: /* Re-mapped from CSI~3 in ansi_getc() */
#endif
case 010: /* ^H */
delete_backward();
break;
case 004: /* ^D */
if (max_pos == 0) {
reset_termio();
return ((char *) NULL);
}
/* intentionally omitting break */
#ifdef DEL_ERASES_CURRENT_CHAR
case 0177: /* DEL */
case 023: /* Re-mapped from CSI~3 in ansi_getc() */
#endif
delete_forward();
break;
case 025: /* ^U */
clear_line(prompt);
break;
case 027: /* ^W */
delete_previous_word();
break;
case '\n': /* ^J */
case '\r': /* ^M */
cur_line[max_pos + 1] = '\0';
#ifdef OS2
while (cur_pos < max_pos) {
user_putc(cur_line[cur_pos]);
cur_pos += 1;
}
#endif
putc(NEWLINE, stderr);
/* Shrink the block down to fit the string ?
* if the alloc fails, we still own block at cur_line,
* but this shouldn't really fail.
*/
new_line = (char *) gp_realloc(cur_line, strlen(cur_line) + 1,
"line resize");
if (new_line)
cur_line = new_line;
/* else we just hang on to what we had - it's not a problem */
line_len = 0;
FPRINTF((stderr, "Resizing input line to %d chars\n", strlen(cur_line)));
reset_termio();
return (cur_line);
default:
break;
}
}
}
}
int main(int argc, char* argv[])
{
int it,kt,ia,is,i1,i2,tdmute,jsx,jsz,jgx,jgz,sxbeg,szbeg,gxbeg,gzbeg, distx, distz;
int *sxz, *gxz;
float tmp, amp, vmax;
float *wlt, *d2x, *d1z, *bndr;
float **v0, **vv, **dcal, **den;
float **sp, **spz, **spx, **svz, **svx, **gp, **gpz, **gpx, **gvz, **gvx;
float ***num, ***adcig;
sf_file vmodl, rtmadcig, vecx, vecz; /* I/O files */
sf_init(argc,argv);
#ifdef _OPENMP
omp_init();
#endif
/*< set up I/O files >*/
vmodl = sf_input ("in"); /* velocity model, unit=m/s */
rtmadcig = sf_output("out"); /* ADCIG obtained by Poynting vector */
vecx=sf_output("vecx");
vecz=sf_output("vecz");
/* get parameters for RTM */
if (!sf_histint(vmodl,"n1",&nz)) sf_error("no n1");
if (!sf_histint(vmodl,"n2",&nx)) sf_error("no n2");
if (!sf_histfloat(vmodl,"d1",&dz)) sf_error("no d1");
if (!sf_histfloat(vmodl,"d2",&dx)) sf_error("no d2");
if (!sf_getfloat("amp",&)) amp=1.e3;
/* maximum amplitude of ricker wavelet*/
if (!sf_getfloat("fm",&fm)) sf_error("no fm");
/* dominant freq of ricker */
if (!sf_getfloat("dt",&dt)) sf_error("no dt");
/* time interval */
if (!sf_getint("nt",&nt)) sf_error("no nt");
/* total modeling time steps */
if (!sf_getint("ns",&ns)) sf_error("no ns");
/* total shots */
if (!sf_getint("ng",&ng)) sf_error("no ng");
/* total receivers in each shot */
if (!sf_getint("nb",&nb)) nb=20;
/* thickness of split PML */
if (!sf_getint("na",&na)) na=30;
/* number of angles*/
if (!sf_getint("kt",&kt)) kt=200;
/* record poynting vector at kt */
if (!sf_getint("jsx",&jsx)) sf_error("no jsx");
/* source x-axis jump interval */
if (!sf_getint("jsz",&jsz)) jsz=0;
/* source z-axis jump interval */
if (!sf_getint("jgx",&jgx)) jgx=1;
/* receiver x-axis jump interval */
if (!sf_getint("jgz",&jgz)) jgz=0;
/* receiver z-axis jump interval */
if (!sf_getint("sxbeg",&sxbeg)) sf_error("no sxbeg");
/* x-begining index of sources, starting from 0 */
if (!sf_getint("szbeg",&szbeg)) sf_error("no szbeg");
/* z-begining index of sources, starting from 0 */
if (!sf_getint("gxbeg",&gxbeg)) sf_error("no gxbeg");
/* x-begining index of receivers, starting from 0 */
if (!sf_getint("gzbeg",&gzbeg)) sf_error("no gzbeg");
/* z-begining index of receivers, starting from 0 */
if (!sf_getbool("csdgather",&csdgather)) csdgather=true;
/* default, common shot-gather; if n, record at every point*/
if (!sf_getfloat("vmute",&vmute)) vmute=1500;
/* muting velocity to remove the low-freq noise, unit=m/s*/
if (!sf_getint("tdmute",&tdmute)) tdmute=2./(fm*dt);
/* number of deleyed time samples to mute */
_dx=1./dx;
_dz=1./dz;
nzpad=nz+2*nb;
nxpad=nx+2*nb;
da=SF_PI/(float)na;/* angle unit, rad; */
var=da/3.;
var=2.0*var*var;
sf_putint(rtmadcig,"n1",nz);
sf_putint(rtmadcig,"n2",nx);
sf_putfloat(rtmadcig,"n3",na);
sf_putfloat(rtmadcig,"d1",dz);
sf_putfloat(rtmadcig,"d2",dx);
sf_putfloat(rtmadcig,"d3",90./(float)na);
/* allocate variables */
wlt=sf_floatalloc(nt);
v0=sf_floatalloc2(nz,nx);
vv=sf_floatalloc2(nzpad, nxpad);
sp =sf_floatalloc2(nzpad, nxpad);
spz=sf_floatalloc2(nzpad, nxpad);
spx=sf_floatalloc2(nzpad, nxpad);
svz=sf_floatalloc2(nzpad, nxpad);
svx=sf_floatalloc2(nzpad, nxpad);
gp =sf_floatalloc2(nzpad, nxpad);
gpz=sf_floatalloc2(nzpad, nxpad);
gpx=sf_floatalloc2(nzpad, nxpad);
gvz=sf_floatalloc2(nzpad, nxpad);
gvx=sf_floatalloc2(nzpad, nxpad);
d1z=sf_floatalloc(nzpad);
d2x=sf_floatalloc(nxpad);
sxz=sf_intalloc(ns);
gxz=sf_intalloc(ng);
dcal=sf_floatalloc2(ng,nt);
bndr=(float*)malloc(nt*8*(nx+nz)*sizeof(float));
den=sf_floatalloc2(nz,nx);
num=sf_floatalloc3(nz,nx,na);
adcig=sf_floatalloc3(nz,nx,na);
/* initialize variables */
for(it=0;it<nt;it++){
tmp=SF_PI*fm*(it*dt-1.0/fm);tmp*=tmp;
wlt[it]=amp*(1.0-2.0*tmp)*expf(-tmp);
}
sf_floatread(v0[0],nz*nx,vmodl);
expand2d(vv, v0);
memset(sp [0],0,nzpad*nxpad*sizeof(float));
memset(spx[0],0,nzpad*nxpad*sizeof(float));
memset(spz[0],0,nzpad*nxpad*sizeof(float));
memset(svx[0],0,nzpad*nxpad*sizeof(float));
memset(svz[0],0,nzpad*nxpad*sizeof(float));
memset(gp [0],0,nzpad*nxpad*sizeof(float));
memset(gpx[0],0,nzpad*nxpad*sizeof(float));
memset(gpz[0],0,nzpad*nxpad*sizeof(float));
memset(gvx[0],0,nzpad*nxpad*sizeof(float));
memset(gvz[0],0,nzpad*nxpad*sizeof(float));
vmax=v0[0][0];
for(i2=0; i2<nx; i2++)
for(i1=0; i1<nz; i1++)
vmax=SF_MAX(v0[i2][i1],vmax);
pmlcoeff_init(d1z, d2x, vmax);
if (!(sxbeg>=0 && szbeg>=0 && sxbeg+(ns-1)*jsx<nx && szbeg+(ns-1)*jsz<nz))
{ sf_error("sources exceeds the computing zone!"); exit(1);}
sg_init(sxz, szbeg, sxbeg, jsz, jsx, ns);
distx=sxbeg-gxbeg;
distz=szbeg-gzbeg;
if (csdgather) {
if (!(gxbeg>=0 && gzbeg>=0 && gxbeg+(ng-1)*jgx<nx && gzbeg+(ng-1)*jgz<nz &&
(sxbeg+(ns-1)*jsx)+(ng-1)*jgx-distx <nx && (szbeg+(ns-1)*jsz)+(ng-1)*jgz-distz <nz))
{ sf_error("geophones exceeds the computing zone!"); exit(1);}
}else{
if (!(gxbeg>=0 && gzbeg>=0 && gxbeg+(ng-1)*jgx<nx && gzbeg+(ng-1)*jgz<nz))
{ sf_error("geophones exceeds the computing zone!"); exit(1);}
}
sg_init(gxz, gzbeg, gxbeg, jgz, jgx, ng);
memset(adcig[0][0], 0, na*nz*nx*sizeof(float));
for(is=0; is<ns; is++)
{
wavefield_init(sp, spz, spx, svz, svx);
if (csdgather) {
gxbeg=sxbeg+is*jsx-distx;
sg_init(gxz, gzbeg, gxbeg, jgz, jgx, ng);
}
for(it=0; it<nt; it++)
{
add_source(&sxz[is], sp, 1, &wlt[it], true);
step_forward(sp, spz, spx, svz, svx, vv, d1z, d2x);
bndr_rw(false, svz, svx, &bndr[it*8*(nx+nz)]);
record_seis(dcal[it], gxz, sp, ng);
muting(dcal[it], gzbeg, szbeg, gxbeg, sxbeg+is*jsx, jgx, it, tdmute);
}
wavefield_init(gp, gpz, gpx, gvz, gvx);
memset(num[0][0], 0, na*nz*nx*sizeof(float));
memset(den[0], 0, nz*nx*sizeof(float));
for(it=nt-1; it>-1; it--)
{
add_source(gxz, gp, ng, dcal[it], true);
step_forward(gp, gpz, gpx, gvz, gvx, vv, d1z, d2x);
if(it==kt)
{
window2d(v0,svx);
sf_floatwrite(v0[0],nz*nx,vecx);
window2d(v0,svz);
sf_floatwrite(v0[0],nz*nx,vecz);
}
bndr_rw(true, svz, svx, &bndr[it*8*(nx+nz)]);
cross_correlation(num, den, sp, gp, svz, svx, gvz, gvx);
step_backward(sp, svz, svx, vv);
add_source(&sxz[is], sp, 1, &wlt[it], false);
}
for(ia=0; ia<na; ia++)
for(i2=0; i2<nx; i2++)
for(i1=0; i1<nz; i1++)
adcig[ia][i2][i1]+=num[ia][i2][i1]/(den[i2][i1]+SF_EPS);
}
sf_floatwrite(adcig[0][0], na*nz*nx,rtmadcig);
free(wlt);
free(*v0); free(v0);
free(*vv); free(vv);
free(*sp); free(sp);
free(*spx); free(spx);
free(*spz); free(spz);
free(*svx); free(svx);
free(*svz); free(svz);
free(*gp); free(gp);
free(*gpx); free(gpx);
free(*gpz); free(gpz);
free(*gvx); free(gvx);
free(*gvz); free(gvz);
free(d1z);
free(d2x);
free(sxz);
free(gxz);
free(bndr);
free(*den); free(den);
free(**num); free(*num); free(num);
free(**adcig); free(*adcig); free(adcig);
exit(0);
}
void prtm2d_lop(bool adj, bool add, int nm, int nd, float *mod, float *dat)
/*< prtm2d linear operator >*/
{
int i1,i2,it,is,ig, gx, gz;
if(nm!=nx*nz) sf_error("model size mismatch: %d!=%d",nm, nx*nz);
if(nd!=nt*ng*ns) sf_error("data size mismatch: %d!=%d",nd,nt*ng*ns);
sf_adjnull(adj, add, nm, nd, mod, dat);
for(is=0; is<ns; is++) {/* it may be parallized using MPI */
/* initialize is-th source wavefield Ps[] */
memset(sp0[0], 0, nzpad*nxpad*sizeof(float));
memset(sp1[0], 0, nzpad*nxpad*sizeof(float));
if (csdgather){
gxbeg=sxbeg+is*jsx-distx;
sg_init(gxz, gzbeg, gxbeg, jgz, jgx, ng);
}
if(adj){/* migration: mm=Lt dd */
for(it=0; it<nt; it++){
add_source(&sxz[is], sp1, 1, &wlt[it], true);
step_forward(sp0, sp1, vv, false);
apply_sponge(sp0);
apply_sponge(sp1);
ptr=sp0; sp0=sp1; sp1=ptr;
boundary_rw(sp0, &rwbndr[it*4*(nx+nz)], false);
}
memset(gp0[0], 0, nzpad*nxpad*sizeof(float));
memset(gp1[0], 0, nzpad*nxpad*sizeof(float));
for (it=nt-1; it >-1; it--) {
/* reverse time order, Img[]+=Ps[]* Pg[]; */
if(verb) sf_warning("%d;",it);
/* reconstruct source wavefield Ps[] */
boundary_rw(sp0, &rwbndr[it*4*(nx+nz)], true);
ptr=sp0; sp0=sp1; sp1=ptr;
step_forward(sp0, sp1, vv, false);
add_source(&sxz[is], sp1, 1, &wlt[it], false);
/* backpropagate receiver wavefield */
for(ig=0;ig<ng; ig++){
gx=gxz[ig]/nz;
gz=gxz[ig]%nz;
gp1[gx+nb][gz+nb]+=dat[it+ig*nt+is*nt*ng];
}
step_forward(gp0, gp1, vv, false);
apply_sponge(gp0);
apply_sponge(gp1);
ptr=gp0; gp0=gp1; gp1=ptr;
for(i2=0; i2<nx; i2++)
for(i1=0; i1<nz; i1++)
mod[i1+nz*i2]+=sp0[i2+nb][i1+nb]*gp1[i2+nb][i1+nb];
}
}else{/* Born modeling/demigration: dd=L mm */
for(it=0; it<nt; it++){
/* forward time order, Pg[]+=Ps[]* Img[]; */
if(verb) sf_warning("%d;",it);
for(i2=0; i2<nx; i2++)
for(i1=0; i1<nz; i1++)
gp1[i2+nb][i1+nb]+=sp0[i2+nb][i1+nb]*mod[i1+nz*i2];
ptr=gp0; gp0=gp1; gp1=ptr;
apply_sponge(gp0);
apply_sponge(gp1);
step_forward(gp0, gp1, vv, true);
for(ig=0;ig<ng; ig++){
gx=gxz[ig]/nz;
gz=gxz[ig]%nz;
dat[it+ig*nt+is*nt*ng]+=gp1[gx+nb][gz+nb];
}
add_source(&sxz[is], sp1, 1, &wlt[it], true);
step_forward(sp0, sp1, vv, false);
apply_sponge(sp0);
apply_sponge(sp1);
ptr=sp0; sp0=sp1; sp1=ptr;
}
}
}
}
/* Go to last position. If display is non-zero the display is updated. */
int goto_last (struct world *world, int display)
{
while (step_forward (world, display) == 0) ;
return 0;
}
