nlsop.c

   1 /*
   2  * nlsop.c
   3  *
   4  * this program tries helping to understand the amorphous depuration
   5  * and recrystallization of SiCx while ion implantation at temperatures
   6  * below 400 degree celsius.
   7  * hopefully the program will simulate the stabilization of the
   8  * selforganizing lamella structure in the observed behaviour.
   9  *
  10  * refs:
  11  *  - J. K. N. Lindner. Habilationsschrift, Universitaet Augsburg.
  12  *  - Maik Haeberlen. Diplomarbeit, Universitaet Augsburg.
  13  */
  14
  15 #define _GNU_SOURCE
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <sys/types.h>
  20 #include <sys/stat.h>
  21 #include <fcntl.h>
  22 #include <unistd.h>
  23
  24 #include "nlsop.h"
  25
  26 #include "dfbapi.h"
  27 #include "random.h"
  28
  29 #define MAKE_AMORPH(N) *(N)|=AMORPH
  30 #define MAKE_CRYST(N) *(N)&=~AMORPH
  31
  32 /* test globals - get removed or included in my_info struct later */
  33 int amorph_count;
  34 int cryst_count;
  35
  36 int usage(void)
  37 {
  38  puts("usage:");
  39  puts("-h \t\t help");
  40  puts("-n \t\t no user interaction");
  41  puts("-Z \t\t cryst -> amorph c diffusion in z direction");
  42  printf("-a <value> \t slope of nuclear energy loss (default %f)\n",A_EL);
  43  printf("-b <value> \t nuclear energy loss offset (default %f)\n",B_EL);
  44  printf("-x <value> \t # x cells (default %d)\n",X);
  45  printf("-y <value> \t # y cells (default %d)\n",Y);
  46  printf("-z <value> \t # z cells (default %d)\n",Z);
  47  printf("-s <value> \t steps (default %d)\n",STEPS);
  48  printf("-d <value> \t refresh display (default %d)\n",REFRESH);
  49  printf("-r <value> \t amorphous influence range (default %d)\n",RANGE);
  50  printf("-f <value> \t pressure = <value> * 1/distance^2 (default %f)\n",A_AP);
  51  printf("-p <value> \t pressure offset (default %f)\n",B_AP);
  52  printf("-F <value> \t proportionality constant between c conc and ability to get amorphous (default %f)\n",A_CP);
  53  printf("-A <value> \t slope of linear c distribution (default %f)\n",A_CD);
  54  printf("-B <value> \t linear c distribution offset (default %f)\n",B_CD);
  55  printf("-D <value> \t diffusion rate from cryst to amorph cells (default %f)\n",DR_AC);
  56  printf("-c <value> \t diffusion rate in cryst cells (default %f)\n",DR_CC);
  57  printf("-e <value> \t do diffusion every <value> steps (default %d)\n",DIFF_RATE);
  58  printf("-W <value> \t write every <value> steps to save file (default %d)\n",RESAVE);
  59  puts("-C <file> \t convert file to gnuplot format");
  60  puts("-L <file> \t load from file");
  61  puts("-S <file> \t save to file");
  62  puts("-R <file> \t read from random file");
  63  puts("-P <file> \t specify implantatin profile file");
  64
  65  return 1;
  66 }
  67
  68 int process_cell(d3_lattice *d3_l,u32 x,u32 y,u32 z,info *my_info)
  69 {
  70  unsigned char *thiz;
  71  int *conc;
  72  int i,j;
  73  int off;
  74  double p;
  75
  76  thiz=d3_l->status+x+y*d3_l->max_x+z*d3_l->max_x*d3_l->max_y;
  77  conc=d3_l->extra+x+y*d3_l->max_x+z*d3_l->max_x*d3_l->max_y;
  78  p=my_info->b_ap*URAND_MAX;
  79  for(i=-(my_info->range);i<=my_info->range;i++)
  80  {
  81   for(j=-(my_info->range);j<=my_info->range;j++)
  82   {
  83    if(!(i==0 && j==0))
  84    {
  85     off=((x+d3_l->max_x+i)%d3_l->max_x)+((y+d3_l->max_y+j)%d3_l->max_x)*d3_l->max_x+z*d3_l->max_x*d3_l->max_y;
  86     if(*(d3_l->status+off)&AMORPH) p+=my_info->a_ap*(*(d3_l->extra+off))*URAND_MAX/(i*i+j*j);
  87    }
  88   }
  89  }
  90  p+=*conc*my_info->a_cp*URAND_MAX;
  91  if(!(*thiz&AMORPH))
  92  {
  93   if(get_rand(URAND_MAX)<=p)
  94   {
  95    MAKE_AMORPH(thiz);
  96    amorph_count++;
  97   }
  98  } else
  99  {
 100   /* assume 1-p probability */
 101   if(get_rand(URAND_MAX)>p)
 102   {
 103    MAKE_CRYST(thiz);
 104    cryst_count++;
 105   }
 106  }
 107
 108  return 1;
 109 }
 110
 111 int distrib_c(d3_lattice *d3_l,info *my_info,int step,double c_ratio)
 112 {
 113  u32 x,y,z;
 114  int i,j,k,c;
 115  int offset,off;
 116  int carry;
 117
 118  /* put one c ion somewhere in the lattice */
 119  if(my_info->cc<c_ratio*step)
 120  {
 121   x=get_rand(d3_l->max_x);
 122   y=get_rand(d3_l->max_y);
 123   z=get_rand_lgp(d3_l->max_z,my_info->a_cd,my_info->b_cd);
 124   *(d3_l->extra+x+y*d3_l->max_x+z*d3_l->max_x*d3_l->max_y)+=1;
 125   (my_info->cc)++;
 126  }
 127
 128  if(step%my_info->diff_rate==0)
 129  {
 130
 131  for(i=0;i<d3_l->max_x;i++)
 132  {
 133   for(j=0;j<d3_l->max_y;j++)
 134   {
 135    for(k=0;k<d3_l->max_z;k++)
 136    {
 137     offset=i+j*d3_l->max_x+k*d3_l->max_x*d3_l->max_y;
 138     /* case amorph - amorph <-> cryst diffusion */
 139     if(*(d3_l->status+offset)&AMORPH)
 140     {
 141      for(c=-1;c<=1;c++)
 142      {
 143       if(c!=0)
 144       {
 145        off=((i+d3_l->max_x+c)%d3_l->max_x)+j*d3_l->max_x+k*d3_l->max_x*d3_l->max_y;
 146        carry=0;
 147        if(!(*(d3_l->status+off)&AMORPH)) carry=(int)(my_info->dr_ac*(*(d3_l->extra+off)));
 148        if(carry!=0)
 149        {
 150         *(d3_l->extra+offset)+=carry;
 151         *(d3_l->extra+off)-=carry;
 152        }
 153       }
 154      }
 155      for(c=-1;c<=1;c++)
 156      {
 157       if(c!=0)
 158       {
 159        off=i+((j+c+d3_l->max_y)%d3_l->max_y)*d3_l->max_x+k*d3_l->max_x*d3_l->max_y;
 160        carry=0;
 161        if(!(*(d3_l->status+off)&AMORPH)) carry=(int)(my_info->dr_ac*(*(d3_l->extra+off)));
 162        if(carry!=0)
 163        {
 164         *(d3_l->extra+offset)+=carry;
 165         *(d3_l->extra+off)-=carry;
 166        }
 167       }
 168      }
 169      if(my_info->z_diff)
 170      {
 171       for(c=-1;c<=1;c++)
 172       {
 173        if(c!=0)
 174        {
 175         off=i+j*d3_l->max_x+((k+c+d3_l->max_z)%d3_l->max_z)*d3_l->max_x*d3_l->max_y;
 176         carry=0;
 177         if(!*(d3_l->status+off)&AMORPH) carry=(int)(my_info->dr_ac*(*(d3_l->extra+off)));
 178         if(carry!=0)
 179         {
 180          *(d3_l->extra+off)-=carry;
 181          *(d3_l->extra+offset)+=carry;
 182         }
 183        }
 184       }
 185      }
 186     } else
 187     /* case not amorph - cryst <-> cryst diffusion */
 188     {
 189      for(c=-1;c<=1;c++)
 190      {
 191       if(c!=0)
 192       {
 193        off=i+((j+c+d3_l->max_y)%d3_l->max_y)*d3_l->max_x+k*d3_l->max_x*d3_l->max_y;
 194        carry=0;
 195        if(!(*(d3_l->status+off)&AMORPH))
 196        {
 197         carry=(int)(my_info->dr_cc*(*(d3_l->extra+off)-*(d3_l->extra+offset))/2);
 198         if(carry!=0)
 199         {
 200          *(d3_l->extra+offset)+=carry;
 201          *(d3_l->extra+off)-=carry;
 202         }
 203        }
 204       }
 205      }
 206      for(c=-1;c<=1;c++)
 207      {
 208       if(c!=0)
 209       {
 210        off=((i+c+d3_l->max_x)%d3_l->max_x)+j*d3_l->max_x+k*d3_l->max_x*d3_l->max_y;
 211        carry=0;
 212        if(!(*(d3_l->status+off)&AMORPH))
 213        {
 214         carry=(int)(my_info->dr_cc*(*(d3_l->extra+off)-*(d3_l->extra+offset))/2);
 215         if(carry!=0)
 216         {
 217          *(d3_l->extra+offset)+=carry;
 218          *(d3_l->extra+off)-=carry;
 219         }
 220        }
 221       }
 222      }
 223     }
 224    } /* for z */
 225   } /* for y */
 226  } /* for x */
 227
 228  } /* if step modulo diff_rate == 0 */
 229
 230  return 1;
 231 }
 232
 233 int calc_pressure(d3_lattice *d3_l,int range)
 234 {
 235  int i,j,off;
 236  double count,max=0;
 237  int x,y,z;
 238
 239  for(x=0;x<d3_l->max_x;x++)
 240  {
 241   for(y=0;y<d3_l->max_y;y++)
 242   {
 243    for(z=0;z<d3_l->max_z;z++)
 244    {
 245     count=0;
 246     for(i=-range;i<=range;i++)
 247     {
 248      for(j=-range;j<=range;j++)
 249      {
 250       if(i!=0 && j!=0)
 251       {
 252        off=((x+d3_l->max_x+i)%d3_l->max_x)+((y+d3_l->max_y+j)%d3_l->max_x)*d3_l->max_x+z*d3_l->max_x*d3_l->max_y;
 253        if(*(d3_l->status+off)&AMORPH) count+=((double)*(d3_l->extra+off))/(i*i+j*j);
 254       }
 255      }
 256     }
 257     if(count>max) max=count;
 258    }
 259   }
 260  }
 261
 262  for(x=0;x<d3_l->max_x;x++)
 263  {
 264   for(y=0;y<d3_l->max_y;y++)
 265   {
 266    for(z=0;z<d3_l->max_z;z++)
 267    {
 268     count=0;
 269     for(i=-range;i<=range;i++)
 270     {
 271      for(j=-range;j<=range;j++)
 272      {
 273       if(i!=0 && j!=0)
 274       {
 275        off=((x+d3_l->max_x+i)%d3_l->max_x)+((y+d3_l->max_y+j)%d3_l->max_x)*d3_l->max_x+z*d3_l->max_x*d3_l->max_y;
 276        if(*(d3_l->status+off)&AMORPH) count+=((double)*(d3_l->extra+off))/(i*i+j*j);
 277       }
 278      }
 279     }
 280     *(unsigned char *)(d3_l->v_ptr+x+y*d3_l->max_x+z*d3_l->max_x*d3_l->max_y)=(unsigned char)(count*255/max);
 281    }
 282   }
 283  }
 284
 285  return 1;
 286 }
 287
 288 int calc_max_extra(d3_lattice *d3_l)
 289 {
 290  int x,y,z;
 291  int off,max=0;
 292
 293  for(x=0;x<d3_l->max_x;x++)
 294  {
 295   for(y=0;y<d3_l->max_y;y++)
 296   {
 297    for(z=0;z<d3_l->max_z;z++)
 298    {
 299     off=x+y*d3_l->max_x+z*d3_l->max_x*d3_l->max_y;
 300     if(*(d3_l->extra+off)>max) max=*(d3_l->extra+off);
 301    }
 302   }
 303  }
 304
 305  return max;
 306 }
 307
 308 int write_bmp(d3_lattice *d3_l,int window,u32 x,u32 y,u32 z)
 309 {
 310  int fd,i,j,size=0,foo=0;
 311  int width=0,height=0;
 312  char bmpfile[MAX_CHARS];
 313  char buf[128];
 314
 315  if(window==1)
 316  {
 317   sprintf(bmpfile,"x-z_%d.bmp",y);
 318   foo=3*d3_l->max_x;
 319   size=(foo+(4-foo%4))*d3_l->max_z;
 320   width=d3_l->max_x;
 321   height=d3_l->max_z;
 322  }
 323  if(window==2)
 324  {
 325   sprintf(bmpfile,"y-z_%d.bmp",x);
 326   foo=3*d3_l->max_y;
 327   size=(foo+(4-foo%4))*d3_l->max_z;
 328   width=d3_l->max_y;
 329   height=d3_l->max_z;
 330  }
 331  if(window==3)
 332  {
 333   sprintf(bmpfile,"x-y_%d.bmp",z);
 334   foo=3*d3_l->max_x;
 335   size=(foo+(4-foo%4))*d3_l->max_y;
 336   width=d3_l->max_x;
 337   height=d3_l->max_y;
 338  }
 339
 340  if((fd=open(bmpfile,O_WRONLY|O_CREAT))<0)
 341  {
 342   puts("cannot open bmp file");
 343   return -1;
 344  }
 345
 346  /* bmpheader */
 347  buf[0]='B'; /* std header start */
 348  buf[1]='M';
 349  buf[2]=(size+0x36)&0xff; /* file size */
 350  buf[3]=(size+0x36)>>8;
 351  memset(buf+4,0,6);
 352  buf[10]=0x36; /* offset to data */
 353  memset(buf+11,0,3);
 354  buf[14]=0x28; /* length of bmp info header */
 355  memset(buf+15,0,3);
 356  buf[18]=width&0xff; /* width and height */
 357  buf[19]=width>>8;
 358  memset(buf+20,0,2);
 359  buf[22]=height&0xff;
 360  buf[23]=height>>8;
 361  memset(buf+24,0,2);
 362  buf[26]=1; /* # planes -> 1 */
 363  buf[27]=0;
 364  buf[28]=24; /* bits per pixel -> 2^24 (true color) */
 365  buf[29]=0;
 366  memset(buf+30,0,4); /* compression -> none */
 367  buf[34]=size&0xff; /* data size */
 368  buf[35]=size>>8;
 369  memset(buf+36,0,2);
 370  buf[38]=0x12; /* res: pixel/meter */
 371  buf[39]=0x0b;
 372  memset(buf+40,0,2);
 373  buf[42]=0x12;
 374  buf[43]=0x0b;
 375  memset(buf+44,0,2);
 376  memset(buf+46,0,8); /* no colors, no important colors */
 377
 378  if(write(fd,buf,54)<54)
 379  {
 380   puts("failed writing bmp header");
 381   return -1;
 382  }
 383  if(window==1)
 384  {
 385   for(j=0;j<d3_l->max_z;j++)
 386   {
 387    for(i=0;i<d3_l->max_x;i++)
 388    {
 389     if(*(d3_l->status+i+y*d3_l->max_x+(d3_l->max_z-j)*d3_l->max_x*d3_l->max_y)&RED) memset(buf,0xff,3);
 390     else memset(buf,0,3);
 391     if(write(fd,buf,3)<3)
 392     {
 393      puts("failed writing rgb values to bmp file");
 394      return-1;
 395     }
 396    }
 397    if(foo%4)
 398    {
 399     memset(buf,0,4-foo%4);
 400     if(write(fd,buf,4-foo%4)<4-foo%4)
 401     {
 402      puts("failed writing 4 byte ending");
 403      return -1;
 404     }
 405    }
 406   }
 407  }
 408  if(window==2)
 409  {
 410   for(j=0;j<d3_l->max_z;j++)
 411   {
 412    for(i=0;i<d3_l->max_y;i++)
 413    {
 414     if(*(d3_l->status+x+i*d3_l->max_x+(d3_l->max_z-j)*d3_l->max_x*d3_l->max_y)&RED) memset(buf,0xff,3);
 415     else memset(buf,0,3);
 416     if(write(fd,buf,3)<3)
 417     {
 418      puts("failed writing rgb values to bmp file");
 419      return-1;
 420     }
 421    }
 422    if(foo%4)
 423    {
 424     memset(buf,0,4-foo%4);
 425     if(write(fd,buf,4-foo%4)<4-foo%4)
 426     {
 427      puts("failed writing 4 byte ending");
 428      return -1;
 429     }
 430    }
 431   }
 432  }
 433  if(window==3)
 434  {
 435   for(j=0;j<d3_l->max_y;j++)
 436   {
 437    for(i=0;i<d3_l->max_x;i++)
 438    {
 439     if(*(d3_l->status+i+(d3_l->max_y-j)*d3_l->max_x+z*d3_l->max_x*d3_l->max_y)&RED) memset(buf,0xff,3);
 440     else memset(buf,0,3);
 441     if(write(fd,buf,3)<3)
 442     {
 443      puts("failed writing rgb values to bmp file");
 444      return -1;
 445     }
 446    }
 447    if(foo%4)
 448    {
 449     memset(buf,0,4-foo%4);
 450     if(write(fd,buf,4-foo%4)<4-foo%4)
 451     {
 452      puts("failed writing 4 byte ending");
 453      return -1;
 454     }
 455    }
 456   }
 457  }
 458  close(fd);
 459
 460  return 1;
 461 }
 462
 463 int save_to_file(char *sf,d3_lattice *d3_l,info *my_inf)
 464 {
 465  int sf_fd,c;
 466
 467  if((sf_fd=open(sf,O_WRONLY|O_CREAT))<0)
 468  {
 469   puts("cannot open save file");
 470   return -1;
 471  }
 472  if(write(sf_fd,d3_l,sizeof(d3_lattice))<sizeof(d3_lattice))
 473  {
 474   puts("failed saving d3 lattice struct");
 475   return -1;
 476  }
 477  if(write(sf_fd,my_inf,sizeof(info))<sizeof(info))
 478  {
 479   puts("failed saving info struct");
 480   return-1;
 481  }
 482  c=d3_l->max_x*d3_l->max_y*d3_l->max_z;
 483  if(write(sf_fd,d3_l->status,c*sizeof(unsigned char))<c*sizeof(unsigned char))
 484  {
 485   puts("failed saving status of d3 lattice sites");
 486   return -1;
 487  }
 488  if(write(sf_fd,d3_l->extra,c*sizeof(int))<c*sizeof(int))
 489  {
 490   puts("failed saving sites concentration");
 491   return -1;
 492  }
 493  close(sf_fd);
 494
 495  return 1;
 496 }
 497
 498 int load_from_file(char *lf,d3_lattice *d3_l,info *my_inf)
 499 {
 500  int lf_fd,c;
 501
 502  if((lf_fd=open(lf,O_RDONLY))<0)
 503  {
 504   puts("cannot open load file");
 505   return -1;
 506  }
 507  if(read(lf_fd,d3_l,sizeof(d3_lattice))<sizeof(d3_lattice))
 508  {
 509   puts("failed reading d3 lattice struct");
 510   return -1;
 511  }
 512  if(read(lf_fd,my_inf,sizeof(info))<sizeof(info))
 513  {
 514   puts("failed reading info struct");
 515   return-1;
 516  }
 517  c=d3_l->max_x*d3_l->max_y*d3_l->max_z;
 518  if((d3_l->status=(unsigned char*)malloc(c*sizeof(unsigned char)))==NULL)
 519  {
 520   puts("cannot allocate status buffer");
 521   return -1;
 522  }
 523  if((d3_l->extra=(int *)malloc(c*sizeof(int)))==NULL)
 524  {
 525   puts("cannot allocate concentration buffer");
 526   return -1;
 527  }
 528  if(read(lf_fd,d3_l->status,c*sizeof(unsigned char))<c*sizeof(unsigned char))
 529  {
 530   puts("failed reading status of d3 lattice sites");
 531   return -1;
 532  }
 533  if(read(lf_fd,d3_l->extra,c*sizeof(int))<c*sizeof(int))
 534  {
 535   puts("failed reading sites concentration");
 536   return -1;
 537  }
 538  close(lf_fd);
 539
 540  return 1;
 541 }
 542
 543 int convert_file(char *cf,d3_lattice *d3_l)
 544 {
 545  int x,y,z;
 546  int c_fd;
 547
 548  if((c_fd=open(cf,O_WRONLY|O_CREAT))<0)
 549  {
 550   puts("cannot open convert file");
 551   return -1;
 552  }
 553  dprintf(c_fd,"# created by nlsop (gnuplot format)\n");
 554  for(x=0;x<d3_l->max_x;x++)
 555  {
 556   for(y=0;y<d3_l->max_y;y++)
 557   {
 558    for(z=0;z<d3_l->max_z;z++)
 559    {
 560     if(*(d3_l->status+x+y*d3_l->max_x+z*d3_l->max_x*d3_l->max_y)&AMORPH) dprintf(c_fd,"%d %d %d\n",x,y,z);
 561    }
 562   }
 563  }
 564  close(c_fd);
 565
 566  return 1;
 567 }
 568
 569 int get_c_ratio(double *c_ratio,char *pfile,info *my_info,d3_lattice *d3_l)
 570 {
 571  double all,a,b,d;
 572  int i,k;
 573  int p_fd;
 574  unsigned char buf[32];
 575  char *p;
 576  unsigned char c;
 577
 578  if((p_fd=open(pfile,O_RDONLY))<0)
 579  {
 580   puts("cannot open profile file");
 581   return -1;
 582  }
 583  k=1;
 584  d=0;
 585  all=0;
 586  while(k)
 587  {
 588   for(i=0;i<32;i++)
 589   {
 590    k=read(p_fd,&c,1);
 591    buf[i]=c;
 592    if(c=='\n') break;
 593   }
 594   if(k)
 595   {
 596    p=strtok(buf," ");
 597    a=atof(p)/10; /* nm */
 598    p=strtok(NULL," ");
 599    b=atof(p);
 600    if(a>my_info->b_cd*CELL_LENGTH && a<(my_info->b_cd+d3_l->max_z)*CELL_LENGTH) d+=b;
 601    all+=b;
 602   }
 603  }
 604  *c_ratio=d/all;
 605  close(p_fd);
 606
 607  return 1;
 608 }
 609
 610 int main(int argc,char **argv)
 611 {
 612  u32 x,y,z,x_c,y_c,z_c;
 613  int i,quit,escape,switchmode,nowait,bmp;
 614  int refresh,resave;
 615  char s_file[MAX_CHARS];
 616  char s_file_tmp[MAX_CHARS];
 617  char l_file[MAX_CHARS];
 618  char c_file[MAX_CHARS];
 619  char p_file[MAX_CHARS];
 620  char convert;
 621  char r_file[MAX_CHARS];
 622 #ifdef USE_DFB_API
 623  char xyz_txt[MAX_TXT];
 624  char status_txt[MAX_TXT];
 625  char conc_txt[MAX_TXT];
 626  char steps_txt[MAX_TXT];
 627  char cc_txt[MAX_TXT];
 628  char a_txt[MAX_TXT];
 629  char s_txt[MAX_TXT];
 630  char ap_txt[MAX_TXT];
 631  char el_txt[MAX_TXT];
 632  char cd_txt[MAX_TXT];
 633  char r_txt[MAX_TXT];
 634  char cp_txt[MAX_TXT];
 635  char zdiff_txt[MAX_TXT];
 636  char diff_txt[MAX_TXT];
 637  char dr_ac_txt[MAX_TXT];
 638  char dr_cc_txt[MAX_TXT];
 639  char dose_txt[MAX_TXT];
 640  char mode_txt[MAX_TXT];
 641  char *arg_v[MAX_ARGV];
 642 #endif
 643  d3_lattice d3_l;
 644  info my_info;
 645  unsigned char mode;
 646  double c_ratio;
 647 #ifdef USE_DFB_API
 648  int max_extra;
 649 #endif
 650
 651  d3_l.max_x=X;
 652  d3_l.max_y=Y;
 653  d3_l.max_z=Z;
 654  my_info.steps=STEPS;
 655  my_info.range=RANGE;
 656  refresh=REFRESH;
 657  resave=RESAVE;
 658  my_info.z_diff=0;
 659  my_info.a_el=A_EL;
 660  my_info.b_el=B_EL;
 661  my_info.a_cd=A_CD;
 662  my_info.b_cd=B_CD;
 663  my_info.a_ap=A_AP;
 664  my_info.b_ap=B_AP;
 665  my_info.a_cp=A_CP;
 666  my_info.cc=CC;
 667  my_info.dr_ac=DR_AC;
 668  my_info.dr_cc=DR_CC;
 669  my_info.diff_rate=DIFF_RATE;
 670  nowait=0;
 671  quit=0;
 672  escape=0;
 673  switchmode=0;
 674  strcpy(s_file,"");
 675  strcpy(l_file,"");
 676  strcpy(c_file,"");
 677  strcpy(p_file,IMP_PROFILE);
 678  convert=0;
 679  strcpy(r_file,"");
 680  mode=0;
 681
 682  amorph_count=0;
 683  cryst_count=0;
 684
 685  for(i=1;i<argc;i++)
 686  {
 687   if(argv[i][0]=='-')
 688   {
 689    switch(argv[i][1])
 690    {
 691     case 'h':
 692      usage();
 693      return -1;
 694     case 'n':
 695      nowait=1;
 696      break;
 697     case 'a':
 698      my_info.a_el=atof(argv[++i]);
 699      break;
 700     case 'b':
 701      my_info.b_el=atof(argv[++i]);
 702      break;
 703     case 'x':
 704      d3_l.max_x=atoi(argv[++i]);
 705      break;
 706     case 'y':
 707      d3_l.max_y=atoi(argv[++i]);
 708      break;
 709     case 'z':
 710      d3_l.max_z=atoi(argv[++i]);
 711      break;
 712     case 'Z':
 713      my_info.z_diff=1;
 714      break;
 715     case 's':
 716      my_info.steps=atoi(argv[++i]);
 717      break;
 718     case 'd':
 719      refresh=atoi(argv[++i]);
 720      break;
 721     case 'r':
 722      my_info.range=atoi(argv[++i]);
 723      break;
 724     case 'f':
 725      my_info.a_ap=atof(argv[++i]);
 726      break;
 727     case 'p':
 728      my_info.b_ap=atof(argv[++i]);
 729      break;
 730     case 'F':
 731      my_info.a_cp=atof(argv[++i]);
 732      break;
 733     case 'A':
 734      my_info.a_cd=atof(argv[++i]);
 735      break;
 736     case 'B':
 737      my_info.b_cd=atof(argv[++i]);
 738      break;
 739     case 'W':
 740      resave=atoi(argv[++i]);
 741      break;
 742     case 'C':
 743      strcpy(l_file,argv[++i]);
 744      if(i<argc-1) if(argv[i+1][0]!='-') strcpy(c_file,argv[++i]);
 745      convert=1;
 746      break;
 747     case 'D':
 748      my_info.dr_ac=atof(argv[++i]);
 749      break;
 750     case 'c':
 751      my_info.dr_cc=atof(argv[++i]);
 752      break;
 753     case 'e':
 754      my_info.diff_rate=atoi(argv[++i]);
 755      break;
 756     case 'L':
 757      strcpy(l_file,argv[++i]);
 758      break;
 759     case 'S':
 760      strcpy(s_file,argv[++i]);
 761      break;
 762     case 'R':
 763      strcpy(r_file,argv[++i]);
 764      break;
 765     case 'P':
 766      strcpy(p_file,argv[++i]);
 767      break;
 768     default:
 769      usage();
 770      return -1;
 771    }
 772   } else usage();
 773  }
 774
 775  x=d3_l.max_x/2-1;
 776  y=d3_l.max_y/2-1;
 777  z=d3_l.max_z/2-1;
 778
 779 #ifdef NODFB
 780  if(!strcmp(s_file,""))
 781  {
 782   puts("NODFB defined, run with -S option");
 783   return -1;
 784  }
 785 #endif
 786
 787  if(!strcmp(r_file,"")) rand_init(NULL);
 788  else rand_init(r_file);
 789
 790  if(!strcmp(l_file,""))
 791  {
 792   i=d3_l.max_x*d3_l.max_y*d3_l.max_z;
 793 #ifdef USE_DFB_API
 794   d3_lattice_init(&argc,argv,&d3_l);
 795 #endif
 796   if((d3_l.status=(unsigned char *)malloc(i*sizeof(unsigned char)))==NULL)
 797   {
 798    puts("failed allocating status buffer");
 799    return -1;
 800   }
 801   memset(d3_l.status,0,i*sizeof(unsigned char));
 802   if((d3_l.extra=(int *)malloc(i*sizeof(int)))==NULL)
 803   {
 804    puts("failed allocating concentration buffer");
 805    return -1;
 806   }
 807   memset(d3_l.extra,0,i*sizeof(int));
 808  } else
 809  {
 810   load_from_file(l_file,&d3_l,&my_info);
 811   if(convert)
 812   {
 813    if(!strcmp(c_file,"")) sprintf(c_file,"%s_gnuplot",l_file);
 814    printf("converting file %s to %s\n",l_file,c_file);
 815    convert_file(c_file,&d3_l);
 816    puts("done");
 817    return 1;
 818   }
 819 #ifdef USE_DFB_API
 820     else d3_lattice_init(&argc,argv,&d3_l);
 821 #endif
 822  }
 823
 824 #ifdef USE_DFB_API
 825  d3_event_init(&d3_l);
 826 #endif
 827
 828 #ifdef USE_DFB_API
 829  strcpy(a_txt,"args:");
 830  sprintf(s_txt,"steps: %d",my_info.steps);
 831  sprintf(dose_txt,"dose: %.2fe+17 C/cm²",my_info.steps*1.0/(d3_l.max_x*d3_l.max_y*CELL_LENGTH*CELL_LENGTH*1000));
 832  sprintf(r_txt,"pressure range: %d",my_info.range);
 833  sprintf(ap_txt,"a_ap: %.3f  b_ap: %.3f",my_info.a_ap,my_info.b_ap);
 834  sprintf(el_txt,"a_el: %.3f  b_el: %.3f",my_info.a_el,my_info.b_el);
 835  sprintf(cd_txt,"a_cd: %.3f  b_cd: %.3f",my_info.a_cd,my_info.b_cd);
 836  sprintf(cp_txt,"a_cp: %.4f",my_info.a_cp);
 837  sprintf(dr_ac_txt,"a/c diffusion rate: %.4f",my_info.dr_ac);
 838  sprintf(dr_cc_txt,"c/c diffusion rate: %.4f",my_info.dr_cc);
 839  sprintf(zdiff_txt,"diffusion in z direction: %c",my_info.z_diff?'y':'n');
 840  sprintf(diff_txt,"diffusion every %d steps",my_info.diff_rate);
 841  strcpy(mode_txt,"view: a/c mode");
 842  arg_v[1]=xyz_txt;
 843  arg_v[2]=NULL;
 844  arg_v[3]=status_txt;
 845  arg_v[4]=conc_txt;
 846  arg_v[5]=NULL;
 847  arg_v[6]=mode_txt;
 848  arg_v[7]=NULL;
 849  arg_v[8]=steps_txt;
 850  arg_v[9]=cc_txt;
 851  arg_v[10]=NULL;
 852  arg_v[11]=diff_txt;
 853  arg_v[12]=zdiff_txt;
 854  arg_v[13]=NULL;
 855  arg_v[14]=a_txt;
 856  arg_v[15]=s_txt;
 857  arg_v[16]=dose_txt;
 858  arg_v[17]=NULL;
 859  arg_v[18]=r_txt;
 860  arg_v[19]=ap_txt;
 861  arg_v[20]=el_txt;
 862  arg_v[21]=cd_txt;
 863  arg_v[22]=cp_txt;
 864  arg_v[23]=NULL;
 865  arg_v[24]=dr_ac_txt;
 866  arg_v[25]=dr_cc_txt;
 867 #endif
 868
 869  if(!strcmp(l_file,""))
 870  {
 871   if(get_c_ratio(&c_ratio,p_file,&my_info,&d3_l)!=1)
 872   {
 873    puts("failed calculating ratio");
 874    return -1;
 875   }
 876   i=0;
 877   while((i<my_info.steps) && (quit==0) && (escape==0))
 878   {
 879    x_c=get_rand(d3_l.max_x);
 880    y_c=get_rand(d3_l.max_y);
 881    z_c=get_rand_lgp(d3_l.max_z,my_info.a_el,my_info.b_el);
 882    distrib_c(&d3_l,&my_info,i,c_ratio);
 883    process_cell(&d3_l,x_c,y_c,z_c,&my_info);
 884 #ifdef USE_DFB_API
 885    if(i%refresh==0)
 886    {
 887     sprintf(xyz_txt,"x: %d  y: %d  z: %d",x+1,y+1,z+1);
 888     sprintf(status_txt,"status: %c",(*(d3_l.status+x+y*d3_l.max_x+z*d3_l.max_x*d3_l.max_y)&AMORPH)?'a':'c');
 889     sprintf(conc_txt,"conc: %d",*(d3_l.extra+x+y*d3_l.max_x+z*d3_l.max_x*d3_l.max_y));
 890     sprintf(steps_txt,"step: %d  a_count: %d",i,amorph_count);
 891     sprintf(cc_txt,"total c: %d  c_count: %d",my_info.cc,cryst_count);
 892     d3_lattice_draw(&d3_l,x,y,z,25,arg_v,mode,0);
 893    }
 894 #endif
 895    if(i%resave==0 && strcmp(s_file,"") && resave!=0 && i!=0)
 896    {
 897     sprintf(s_file_tmp,"%s_%d_of_%d",s_file,i,my_info.steps);
 898     save_to_file(s_file_tmp,&d3_l,&my_info);
 899 #ifdef NODFB
 900     printf("saved %s\n",s_file_tmp);
 901 #endif
 902    }
 903    i++;
 904   }
 905  }
 906
 907  if(strcmp(s_file,""))
 908  {
 909    printf("saved %s\n",s_file);
 910    save_to_file(s_file,&d3_l,&my_info);
 911  }
 912
 913 #ifdef USE_DFB_API
 914  /* allocating buffer for pressure values */
 915  if((d3_l.v_ptr=malloc(d3_l.max_x*d3_l.max_y*d3_l.max_z*sizeof(unsigned char)))==NULL)
 916  {
 917   puts("cannot allocate buffer for pressure values");
 918   return -1;
 919  }
 920  /* calc values */
 921  calc_pressure(&d3_l,my_info.range);
 922  max_extra=calc_max_extra(&d3_l);
 923
 924  while((quit==0) && (escape==0) && (nowait==0))
 925  {
 926   /* bahh! */
 927   if(switchmode==0) mode=0;
 928   if(switchmode==1) mode=1;
 929   if(switchmode==2) mode=2;
 930   /* end of bahh! */
 931   sprintf(xyz_txt,"x: %d  y: %d  z: %d",x+1,y+1,z+1);
 932   sprintf(status_txt,"status: %c",(*(d3_l.status+x+y*d3_l.max_x+z*d3_l.max_x*d3_l.max_y)&AMORPH)?'a':'c');
 933   sprintf(conc_txt,"conc: %d",*(d3_l.extra+x+y*d3_l.max_x+z*d3_l.max_x*d3_l.max_y));
 934   sprintf(steps_txt,"step: end");
 935   sprintf(cc_txt,"total c: %d",my_info.cc);
 936   if(switchmode==0) strcpy(mode_txt,"view: a/c mode");
 937   if(switchmode==1) strcpy(mode_txt,"view: c conc mode");
 938   if(switchmode==2) strcpy(mode_txt,"view: a pressure mode");
 939   d3_lattice_draw(&d3_l,x,y,z,25,arg_v,mode,max_extra);
 940   bmp=0;
 941   scan_event(&d3_l,&x,&y,&z,&quit,&escape,&switchmode,&bmp);
 942   if(bmp) write_bmp(&d3_l,bmp,x,y,z);
 943
 944  }
 945
 946  d3_lattice_release(&d3_l);
 947 #endif
 948
 949  return 1;
 950 }