コード例 #1
0
int main(int argc, char** argv) {

  char *infile;
  infile=argv[1];
  char *outfile;
  outfile=argv[2];

    
  if(argc!=3) {
    printf("Usage: ./convert2gadgetformat2 <infile> <outfile>\n");
    return 0;
  }

  /* load snapshot file */
  io_header header;
  particle_data * P;
  int nTot;
  nTot = load_snapshot(infile, &header, &P);


 
  /* output information about the simulation */
  printf(">> Output from Header \n");
  printf("Boxsize of Simulation: %g\n", header.BoxSize);
  printf("Number of gas particles: %i\n", header.npart[0]);
  printf("Number of high-res dm particles: %i\n", header.npart[1]);
  printf("Number of low-res dm particles: %i\n", header.npart[5]);
  printf("Number of star particles: %i\n", header.npart[4]);

  /* write reduced snapshot file */
  write_snapshot2(outfile, &header, P);

  return 0;
}
コード例 #2
0
ファイル: snapshot.c プロジェクト: nya3jp/scratch
int load_init_snapshot(void) {
    if (!umxfile)
        return 0;
    if (load_snapshot(umxfile) == -1)
        return -1;
    fclose(umxfile);
    io_print_backlog();
    return 0;
}
コード例 #3
0
/* Here we load a snapshot file. It can be distributed
 * onto several files (for files>1).
 * The particles are brought back into the order
 * implied by their ID's.
 * A unit conversion routine is called to do unit
 * conversion, and to evaluate the gas temperature.
 */
int main(int argc, char **argv)
{
  char path[200], input_fname[200], basename[200];
  int type, snapshot_number, files;


  sprintf(path, "/home/tczhang/desktop/C");
  sprintf(basename, "snapshot");
  snapshot_number = 6;		/* number of snapshot */
  files = 1;			/* number of files per snapshot */


  sprintf(input_fname, "%s/%s_%03d", path, basename, snapshot_number);
  load_snapshot(input_fname, files);


  reordering();			/* call this routine only if your ID's are set properly */

  unit_conversion();		/* optional stuff */

  do_what_you_want();
}
コード例 #4
0
ファイル: snap2arr.c プロジェクト: N-BodyShop/tests
/* Here we load one block of a snapshot file. It can be distributed
 * onto several files (for files>1).  It then gets output as an array file.
 */
int main(int argc, char **argv)
{
  char basename[200];
  int  type, files;
  int block_nr;
  int iDim;
  int i;
  int j;
  
  if(argc != 3 && argc != 4) 
    {
      fprintf(stderr,
	      "usage: snap2arr block snapbase [N_files]\n");
      exit(-1);
    }

  block_nr = atoi(argv[1]);
  strcpy(basename, argv[2]);
  
  if(argc == 4 ) 
    {
      files = atoi(argv[3]);	/* # of files per snapshot */
    }
  else 
    files = 1;

  iDim = load_snapshot(basename, block_nr, files);

  for(i=1; i<=NumPart; i++) {
      for(j = 0; j < iDim; j++) {
	  printf("%g\n", P[i].Pos[j]);
	  }
      }
  free_memory(); 

  return 0;
}
コード例 #5
0
/* Here we load a snapshot file. It can be distributed
 * onto several files (for files>1).
 * The particles are brought back into the order
 * implied by their ID's.
 * A unit conversion routine is called to do unit
 * conversion, and to evaluate the gas temperature.
 */
int main(int argc, char **argv)
{
  char path[200], input_fname[200], output_fname[200], basename[200], basenameout[200];
  int  j, n, type, snapshot_number, files, Ngas, random, ncount, ncounthalo1, ncount2;
  double x,y,z,x1,y1, z1, delr;
  double nh, nhmax, nhmax2, mass, mmax, mmax2, dis, xmax, xmax2, ymax, ymax2, zmax, zmax2, sl, masstot, temp, tmax, h2, h2max, gam, gammin;
  double sinkposx, sinkposy, sinkposz, disAU, vrad, vrotx, vroty, vrotz, vrot;
  double velx, vely, velz;
  double dum_num;
  FILE *outfile;


  sprintf(path, "/work/utexas/ao/minerva");
  sprintf(basename, "hires_am2");
  sprintf(basenameout, "snaphires_am2_chem");

  for(j=2;j<=2;j++){

  snapshot_number= j;                   /* number of snapshot */
  files=1;                               /* number of files per snapshot */

  sprintf(input_fname, "%s/%s_%03d", path, basename, snapshot_number);
  sprintf(output_fname, "%s/%s_%03d", path, basenameout, snapshot_number);
  Ngas = load_snapshot(input_fname, files);

  /*    reordering();*/ /* call this routine only if your ID's are set properly */

  unit_conversion();  

  outfile=fopen(output_fname, "w");

  ncount = 0;
  ncount2 = 0;

  nhmax = nhmax2 = 0;
  mmax= mmax2 = 0;
  xmax= xmax2 = 0;
  ymax= ymax2 = 0;
  zmax= zmax2 = 0;
  sl = 0;
  tmax=0;
  h2max=0;


  for(n = 1; n <= Ngas; n++)
       {
       if(P[n].Id == 3755078)
          {
          sinkposx = P[n].Pos[0];
          sinkposy = P[n].Pos[1];
          sinkposz = P[n].Pos[2];
          }
       }


  for(n=1;n<=Ngas;n++) { 
    x=P[n].Pos[0];
    y=P[n].Pos[1];
    z=P[n].Pos[2];

    x1=x/(0.7e0*(1.e0 + 18.9e0));
    y1=y/(0.7e0*(1.e0 + 18.9e0));
    z1=z/(0.7e0*(1.e0 + 18.9e0));

          nh = P[n].nh;
          mass=P[n].Mass;
          masstot=masstot+mass;
          h2 = P[n].H2I;

          if(nh > nhmax2 && mass < 3.e-12)
            {
              nhmax2 = nh;
              mmax2=mass;
              xmax2=P[n].Pos[0];
              ymax2=P[n].Pos[1];
              zmax2=P[n].Pos[2];

            }


          if(nh > nhmax)
            {
              nhmax = nh;
              mmax=mass;
              xmax=P[n].Pos[0];
              ymax=P[n].Pos[1];
              zmax=P[n].Pos[2];
              h2max=P[n].H2I;
            }
    }


    random = rand();
    dum_num = 5.0;

         sinkposx=xmax;
         sinkposy=ymax;
         sinkposz=zmax; 
         printf("sinkposx = %g, sinkposy = %g, sinkposz = %g\n", sinkposx, sinkposy, sinkposz);

         printf("nhmax2 = %lg, maxmass2 = %lg, xmax2 = %lg, ymax2 = %lg, zmax2 = %lg\n", nhmax2, mmax2, xmax2, ymax2, zmax2);

         for(n = 1; n <= Ngas; n++)
             {


             dis = pow(((P[n].Pos[0]-sinkposx)*(P[n].Pos[0]-sinkposx) + (P[n].Pos[1]-sinkposy)*(P[n].Pos[1]-sinkposy) + (P[n].Pos[2]-sinkposz)*(P[n].Pos[2]-sinkposz)), 0.5);
             dis=dis*1.e3*Time/(0.7);
             disAU=dis*206264.806;


      if (/*(random*(1.e0/RAND_MAX))< 0.1e0*/ /* P[n].nh > 1.e4 || P[n].sink > 0.5*/ P[n].Id % 100 == 0) {
      //fprintf(outfile,"%15.13g %8d %15.13g %15.13g %15.13g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g\n", P[n].sink, Id[n],x,y,z,P[n].Temp,P[n].nh,P[n].HII,P[n].H2I,P[n].HDI, P[n].gam, P[n].Vel[0],P[n].Vel[1],P[n].Vel[2],P[n].hsm, P[n].Mass);
      fprintf(outfile,"%15.13g %8d %15.13g %15.13g %15.13g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g\n", dum_num, P[n].Id,P[n].Pos[0],P[n].Pos[1],P[n].Pos[2],dum_num,P[n].nh,P[n].HII,P[n].H2I,P[n].HDI, dum_num, disAU, vrad, vrot,dum_num, P[n].Mass);
      ncount = ncount + 1;
       }

    delr = sqrt((226.791-x)*(226.791-x) + (230.096-y)*(230.096-y) + (230.16-z)*(230.16-z))/(0.7e0*19.98);
  }
  printf("ncount = %d.\n", ncount);
  printf("ncount2 = %d.\n", ncount2);

   printf("nhmax= %g\n", nhmax);
   printf("mmax= %g\n", mmax);
   printf("xmax= %g\n", xmax);
   printf("ymax= %g\n", ymax);
   printf("zmax= %g\n", zmax);
   printf("sl = %g\n", sl);
   printf("tmax = %g\n", tmax);
   printf("h2max = %g\n", h2max);


  fclose(outfile);
}

  do_what_you_want();
}
コード例 #6
0
/* Here we load a snapshot file. It can be distributed
 * onto several files (for files>1).
 * The particles are brought back into the order
 * implied by their ID's.
 * A unit conversion routine is called to do unit
 * conversion, and to evaluate the gas temperature.
 */
int main(int argc, char **argv)
{
  char path[200], input_fname[200], output_fname[200], basename[200], basenameout[200];
  int  i, j, jnum, n, type, snapshot_number, files, random, ncount, ncounthalo1, ncount2, idmax;
  double x,y,z,x1,y1, z1, delr, vx, vy, vz, vel, typemax, dismax;
  double nh, nhmax, mass, mmax, dis, xmax, ymax, zmax, sl, masstot, temp, tmax, h2, h2max, gam, gammin;
  double sinkposx, sinkposy, sinkposz, disAU, vrad, vrotx, vroty, vrotz, vrot, mh_mass;
  double xCOM, yCOM, zCOM, vxCOM, vyCOM, vzCOM, disCOM, vCOM, ncount_doub;
  double hubble_param;
  FILE *outfile;

  sprintf(path, "/work/00863/minerva/strom");

  sprintf(basename, "strom");
  sprintf(basenameout, "snapstrom");

  jnum = 800;

  for(j=jnum;j<=jnum;j=j+5){

  snapshot_number= j;                   /* number of snapshot */
  files=1;                               /* number of files per snapshot */

  if(j<=999)
  {
  sprintf(input_fname, "%s/%s_%04d", path, basename, snapshot_number);
  sprintf(output_fname, "%s/%s_%04d", path, basenameout, snapshot_number);
  }

  if(j>999)
  {
    sprintf(input_fname, "%s/%s_%04d", path, basename, snapshot_number);
    sprintf(output_fname, "%s/%s_%04d", path, basenameout, snapshot_number);
  }

  Ngas = load_snapshot(input_fname, files);

  //for NON-comoving integrations
  Time = hubble_param = 1.0;

  /*    reordering();*/ /* call this routine only if your ID's are set properly */

  printf("hi 1, Ngas = %d, NumPart = %d\n", Ngas, NumPart);

  unit_conversion();  

  printf("hi 2\n");

  outfile=fopen(output_fname, "w");

  ncount = 0;
  ncount2 = 0;

  printf("hi 3\n");

  nhmax = 0;
  mmax = mh_mass = 0;
  xmax = ymax = zmax = 0;
  sl = tmax = h2max = gammin=0;
  masstot = dismax = 0;
  typemax = 5;
  xCOM = yCOM = zCOM = vxCOM = vyCOM = vzCOM = ncount_doub = 0.0;

  printf("hi 4\n");

  for(n=0;n<Ngas;n++) { 

          nh = P[n].nh;
          mass=P[n].Mass;
          temp = P[n].Temp;
          h2 = P[n].H2I;
          gam=P[n].gam;

          if(nh > nhmax)
          //if(mass > mmax)
            {
              //printf("Found the sink!\n");
              nhmax = nh;
              mmax=mass;
              xmax=P[n].Pos[0];
              ymax=P[n].Pos[1];
              zmax=P[n].Pos[2];
              sl = P[n].hsm;
              tmax=P[n].Temp;
              h2max=P[n].H2I;
              gammin=P[n].gam;
              typemax = P[n].Type;
              idmax = P[n].Id;
              vx = P[n].Vel[0];
              vy = P[n].Vel[1];
              vz = P[n].Vel[2];
            }
    }

         for(n=0;n<=Ngas;n++)
           {
            nh = P[n].nh;
            if(nh > nhmax/1e8)
            {
            vxCOM = vxCOM + P[n].Vel[0]*P[n].Mass;
            vyCOM = vyCOM + P[n].Vel[1]*P[n].Mass;
            vzCOM = vzCOM + P[n].Vel[2]*P[n].Mass;
            xCOM = xCOM + P[n].Pos[0]*P[n].Mass;
            yCOM = yCOM + P[n].Pos[1]*P[n].Mass;
            zCOM = zCOM + P[n].Pos[2]*P[n].Mass;
            ncount_doub = ncount_doub + P[n].Mass;
            }
            //if(nh > 1.e6)
            //if(nh > 1e3 && nh < 1e5)
              //printf("ID = %d, nh = %lg\n", P[n].Id, P[n].nh);
              //printf("%d\n", P[n].Id);
         }


         vx = vxCOM/ncount_doub;
         vy = vyCOM/ncount_doub;
         vz = vzCOM/ncount_doub;


         sinkposx=xmax;
         sinkposy=ymax;
         sinkposz=zmax;
         printf("sinkposx = %15.11g, sinkposy = %15.11g, sinkposz = %15.11g, nhmax = %15.11g, mmax = %15.11g\n", sinkposx, sinkposy, sinkposz, nhmax, mmax);

         vx = vy = vz = 0;
         sinkposx = sinkposy = sinkposz = header1.BoxSize/2.0; 

         if(nhmax < 1.e1)
           {
           sinkposx=header1.BoxSize/2.0;
           sinkposy=header1.BoxSize/2.0;
           sinkposz=header1.BoxSize/2.0; 
           }
         printf("sinkposx = %15.11g, sinkposy = %15.11g, sinkposz = %15.11g\n", sinkposx, sinkposy, sinkposz);
         printf("vx = %lg, vy = %lg, vz = %lg\n", vx, vy, vz);

         for(n = 0; n < NumPart; n++)
         //for(n = 0; n < Ngas; n++)
             {

             P[n].Vel[0] = P[n].Vel[0] - vx;
             P[n].Vel[1] = P[n].Vel[1] - vy;
             P[n].Vel[2] = P[n].Vel[2] - vz;

             x = P[n].Pos[0];
             y = P[n].Pos[1];
             z = P[n].Pos[2];

             dis = pow(((P[n].Pos[0]-sinkposx)*(P[n].Pos[0]-sinkposx) + (P[n].Pos[1]-sinkposy)*(P[n].Pos[1]-sinkposy) + (P[n].Pos[2]-sinkposz)*(P[n].Pos[2]-sinkposz)), 0.5);
             //dis = pow(((P[n].Pos[0]-xmax)*(P[n].Pos[0]-xmax) + (P[n].Pos[1]-ymax)*(P[n].Pos[1]-ymax) + (P[n].Pos[2]-zmax)*(P[n].Pos[2]-zmax)), 0.5);
             if(dis > dismax)
                dismax = dis;
             dis=dis*1.e3*Time/hubble_param;
             disAU=dis*206264.806;

             vel = P[n].Vel[0]*P[n].Vel[0] + P[n].Vel[1]*P[n].Vel[1] + P[n].Vel[2]*P[n].Vel[2];
             vel = pow(vel,0.5)*pow(Time, 0.5); 

             vrad =  (P[n].Vel[0]*(P[n].Pos[0]-sinkposx) + P[n].Vel[1]*(P[n].Pos[1]-sinkposy) + P[n].Vel[2]*(P[n].Pos[2]-sinkposz))/pow(((P[n].Pos[0]-sinkposx)*(P[n].Pos[0]-sinkposx) + (P[n].Pos[1]-sinkposy)*(P[n].Pos[1]-sinkposy) + (P[n].Pos[2]-sinkposz)*(P[n].Pos[2]-sinkposz)), 0.5);
             vrad = vrad*pow(Time, 0.5); 

             vrotx = (P[n].Pos[1]-sinkposy)*P[n].Vel[2]  - (P[n].Pos[2]-sinkposz)*P[n].Vel[1];
             vroty = (P[n].Pos[2]-sinkposz)*P[n].Vel[0] - (P[n].Pos[0]-sinkposx)*P[n].Vel[2];
             vrotz = (P[n].Pos[0]-sinkposx)*P[n].Vel[1]  -  (P[n].Pos[1]-sinkposy)*P[n].Vel[0];


             vrot = pow(vrotx*vrotx + vroty*vroty + vrotz*vrotz, 0.5); 
             vrot = vrot*pow(Time, 0.5)/pow(((P[n].Pos[0]-sinkposx)*(P[n].Pos[0]-sinkposx) + (P[n].Pos[1]-sinkposy)*(P[n].Pos[1]-sinkposy) + (P[n].Pos[2]-sinkposz)*(P[n].Pos[2]-sinkposz)), 0.5);
;  //convert to km/s

             if(n%10000 == 0)
               printf("ID = %d, nh = %lg, temp = %lg, elec %lg, H2 = %lg HeII = %lg mass = %lg\n", P[n].Id, P[n].nh, P[n].Temp, P[n].HII, P[n].H2I, P[n].HeII, P[n].Mass);

             //f(P[n].nh > 1.e10 && P[n].sink > -4)
             if(disAU <= 1.e2 /*&& P[n].sink < -4*/)
               masstot = masstot + P[n].Mass/1.e-10/hubble_param;

             if(P[n].sink > 0 && P[n].nh > 8.0e13)
               printf("Mass = %g sink = %g ID = %d nh = %lg Dens = %lg Temp = %lg dis = %lg, vel = %lg, vrad = %lg, vrot = %lg\n", P[n].Mass, P[n].sink, P[n].Id, P[n].nh, P[n].Rho, P[n].Temp, disAU, vel, vrad, vrot);


    random = rand();

    if((random*(1.e0/RAND_MAX)< 0.2 && P[n].nh > 3.e-2) /*|| P[n].nh > 2.e1*/ /*&& P[n].sink < 0*/ /* ||  P[n].sink > 0.5*/ || P[n].Id < 3 ) 
    //if(P[n].nh > 1.e4 /*&& random*(1.e0/RAND_MAX)< 0.1e0*/ /*|| P[n].sink > 0.5 || (random*(1.e0/RAND_MAX))< 0.02e0*/) 
    //if(dis < 1.e1)
      {
      fprintf(outfile,"%15.13g %12d %15.13g %15.13g %15.13g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g\n", P[n].sink, P[n].Id,x,y,z,P[n].Temp,P[n].nh,P[n].HII,P[n].H2I,P[n].HDI, P[n].gam, disAU, vrad, vrot,P[n].Vel[0], P[n].Mass);
      //fprintf(outfile,"%15.13g %12d %15.13g %15.13g %15.13g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %15.6g %lg %lg %15.6g %15.6g\n", P[n].sink, Id[n],x,y,z,P[n].Temp,P[n].nh,P[n].HII,P[n].H2I,P[n].HDI, P[n].gam, disAU, P[n].Vel[0]*pow(Time, 0.5), P[n].Vel[2]*pow(Time, 0.5), P[n].hsm, P[n].Mass);
      ncount = ncount + 1;
      }
  }
  printf("ncount = %d.\n", ncount);
  printf("ncount2 = %d.\n", ncount2);

   printf("nhmax= %g\n", nhmax);
   printf("mmax= %g\n", mmax);
   printf("xmax= %15.11g\n", xmax);
   printf("ymax= %15.11g\n", ymax);
   printf("zmax= %15.11g\n", zmax);
   printf("sl = %g\n", sl);
   printf("tmax = %g\n", tmax);
   printf("h2max = %g\n", h2max);
   printf("gammin = %g\n", gammin);
   printf("typemax = %lg\n", typemax);
   printf("idmax = %d\n", idmax);
   printf("sink = %g\n", P[n-1].sink);
   printf("masstot = %g\n", masstot);
   printf("dismax = %g\n", dismax);

  fclose(outfile);
  free(P);
}

  do_what_you_want();
}
コード例 #7
0
int main(int argc, char **argv)
  {
    int i = 0;
    int j = 0;
    int n = 0;
    int m = 0;
    int i_min = 0;
    int i_max = 0;
    int j_min = 0;
    int j_max= 0;
    int flag_i = 0;
    int flag_j = 0;
    int N_dm = 0;
    int N_grid = 700;
    int N_begin = 3051;
    int N_end = 3099;
    //int N_begin = 2550;
    //int N_end = 2555;


//    int n_grid1[N_grid][N_grid];
    double n_grid1[N_grid][N_grid];
//    int n_grid2[N_grid][N_grid];
    double n_grid2[N_grid][N_grid];

    double center_x = 70.286000395;  //hires3 center
    double center_y = 70.266843068;
    double center_z = 69.644125951;

    double width = 140.;
    double slice = 140.;
    double entries = 0.0;
    double temp_pos = 0.0;
    double min = 1.e-4;
    double max = 1.e-1;
    double abs_min = min;
    double abs_max = max;
    double time_in_Myr = 0.0;
    double grid1[N_grid][N_grid];
    double grid2[N_grid][N_grid];
    double grid3[1][N_grid];
    char dir[500];
    char buf[500];
    FILE *infile;
    FILE *outfile;
    int files;
    int N_gas;
    double hsml_factor=1.7;
    double center_i, center_j, W_x, weight, h, x2, x;
    double nh, nhmax, xmax, ymax, zmax, vx, vy, vz, xCOM, yCOM, zCOM, vxCOM, vyCOM, vzCOM, ncount_doub;

    files=1;

    double IDmass=0.0;
    int IDsink;

    //sprintf(dir, "/work/00863/minerva/ds_nr6e");
    //sprintf(dir, "/nobackupp1/astacy/bin_HR1");
    //sprintf(dir, "/nobackupp1/astacy/hires2");
    sprintf(dir, "/nobackupp1/astacy/hires_test10");
    //sprintf(dir, "/nobackupp1/astacy/hires_nf3");


    for(m = N_begin; m < N_end+1; m=m+1)
      {
        if(m < 10)
          {
            sprintf(buf, "%s_00%d", dir, m);

            printf("reading 00%d...\n", m);

            N_gas=load_snapshot(buf, files);

            sprintf(buf, "%s_00%d.H2xz", dir, m);

            printf("processing 00%d...\n", m);
          }
        else if(m > 9 && m < 100)
          {
            sprintf(buf, "%s_0%d", dir, m);

            printf("reading 0%d...\n", m);

            N_gas=load_snapshot(buf, files);

            sprintf(buf, "%s_0%d.H2xz", dir, m);

            printf("processing 0%d...\n", m);
          }
        else
          {
            sprintf(buf, "%s_%d", dir, m);

            printf("reading %d...\n", m);

            N_gas=load_snapshot(buf, files);

            sprintf(buf, "%s_%d.H2xz", dir, m);

            printf("processing %d...\n", m);
          }

        //width= 7.5*4.85e-4*header.HubbleParam/(1.e3*header.time);  //cut out central 750 AU
        //slice= 7.5*4.85e-4*header.HubbleParam/(1.e3*header.time);

	width= 5*4.85e-4*header.HubbleParam/(1.e3*header.time);  //500 AU   
        slice= 5*4.85e-4*header.HubbleParam/(1.e3*header.time);  

        //width= 2.4e-2*header.HubbleParam/(1.e3*header.time);
        //slice= 2.4e-2*header.HubbleParam/(1.e3*header.time);


        IDmass = 0.0;
        IDsink = 0;


        for(n = 0; n < N_gas; n++)
          {
            P[n].nh = P[n].Density*unit_mass/pow(unit_length,3.0)*pow(header.HubbleParam,2.0)/pow(header.time,3.0)*X/m_H;
            if (n%100000 ==0) printf("%lg\n", P[n].nh);
          }
  
         xCOM = yCOM = zCOM = vxCOM = vyCOM = vzCOM = ncount_doub = nhmax = 0;
         for(n=0;n < N_gas; n++) 
            {
             nh = P[n].nh;
             if(nh > nhmax)
               {
               nhmax = nh;
               xmax=P[n].Pos[0];
               ymax=P[n].Pos[1];
               zmax=P[n].Pos[2];
               vx = P[n].Vel[0];
               vy = P[n].Vel[1];
               vz = P[n].Vel[2];
               }
            }


         for(n=0;n < N_gas; n++)
            {
            nh = P[n].nh;
            if(nh > nhmax/10.0)
              {
              vxCOM = vxCOM + P[n].Vel[0]*P[n].Mass;
              vyCOM = vyCOM + P[n].Vel[1]*P[n].Mass;
              vzCOM = vzCOM + P[n].Vel[2]*P[n].Mass;
              xCOM = xCOM + P[n].Pos[0]*P[n].Mass;
              yCOM = yCOM + P[n].Pos[1]*P[n].Mass;
              zCOM = zCOM + P[n].Pos[2]*P[n].Mass;
              ncount_doub = ncount_doub + P[n].Mass;
              }
            }

         vx = vxCOM/ncount_doub;
         vy = vyCOM/ncount_doub;
         vz = vzCOM/ncount_doub;

         center_x=xCOM/ncount_doub;
         center_y=yCOM/ncount_doub;
         center_z=zCOM/ncount_doub;


        time_in_Myr = 2.0/3.0/Hubble/header.HubbleParam/sqrt(header.Omega0)*pow(header.time,3.0/2.0)/1.0e6/yr;

        flag_i = 0;
        flag_j = 0;

        for(i = 0; i < N_grid; i++)
          {
            for(j = 0; j < N_grid; j++)
              {
                n_grid1[i][j] = 0;

                grid1[i][j] = 0.0;
              }
          }

        for(n = 0; n < N_gas; n++)
          {
            if(P[n].sink > -1 && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < slice/2.0)
              {

h = fmax(hsml_factor * P[n].Hsml, width / N_grid / 2.0);
weight = P[n].nh * P[n].nh;

if(P[n].sink > 0)
 //h = hsml_factor * 3.57101e-07;
 h = hsml_factor * 2.5696e-08;

                i = 0;
                j=0;

                i_min = int((P[n].Pos[0]-h-center_x+width/2.0)/width*N_grid);

                if(i_min < 0)
                  {
                    i_min = 0;
                  }

                i_max = int((P[n].Pos[0]+h-center_x+width/2.0)/width*N_grid);

                if(i_max > N_grid-1)
                  {
                    i_max = N_grid-1;
                  }

                j_min = int((P[n].Pos[2]-h-center_z+width/2.0)/width*N_grid);

                if(j_min < 0)
                  {
                    j_min = 0;
                  }

                j_max = int((P[n].Pos[2]+h-center_z+width/2.0)/width*N_grid);

                if(j_max > N_grid-1)
                  {
                    j_max = N_grid-1;
                  }

                do
                  {
                    if(i >= i_min && i <= i_max)
                      {
                        flag_i = 1;

center_i = center_x - width / 2.0 + (i + 0.5) * width / (double) N_grid;
                        do
                          {
                            if(j >= j_min && j <= j_max)
                              {
                                flag_j = 1;

center_j = center_z - width / 2.0 + (j + 0.5) * width / (double) N_grid;

x2 = ((P[n].Pos[0] - center_i) * (P[n].Pos[0] - center_i) + (P[n].Pos[2] - center_j) * (P[n].Pos[2] - center_j)) / h / h;

if(x2 <= 1.0)
  {
    x = sqrt(x2);

    if(x <= 0.5)
      W_x = 1.0 - 6.0 * x * x + 6.0 * x * x * x;
    else
      W_x = 2.0 * (1.0 - x) * (1.0 - x) * (1.0 - x);

    grid1[i][j] += weight * P[n].H2I * W_x;

    n_grid1[i][j] += weight * W_x;
   }


               //                 n_grid1[i][j] += 1;

                 //               grid1[i][j] += P[n].nh;
                              }
                            else if(j > j_max)
                              {
                                flag_j = 2;
                              }
                            else
                              {
                                flag_j = 0;
                              }

                             j++;
                           }
                         while((flag_j == 0 || flag_j == 1) && j < N_grid);

                         j = 0;
                       }
                     else if(i > i_max)
                       {
                         flag_i = 2;
                       }
                     else
                       {
                         flag_i = 0;
                       }

                     i++;
                   }
                 while((flag_i == 0 || flag_i == 1) && i < N_grid);

                 i = 0;
               }
           }

        for(i = 0; i < N_grid; i++)
          {
            for(j = 0; j < N_grid; j++)
              {
                if(n_grid1[i][j] > 0)
                  {
                    grid1[i][j] /= double(n_grid1[i][j]);
                  }

                if(grid1[i][j] < min)
                  {
                    grid1[i][j] = min;
                  }

                if(grid1[i][j] > max)
                  {
                    grid1[i][j] = max;
                  }

                grid1[i][j] = log10(grid1[i][j]);
              }
           }

        grid1[0][0] = log10(abs_min);
        grid1[N_grid-1][N_grid-1] = log10(abs_max);

        flag_i = 0;
        flag_j = 0;

        for(i = 0; i < N_grid; i++)
          {
            for(j = 0; j < N_grid; j++)
              {
                n_grid2[i][j] = 0;

                grid2[i][j] = 0.0;
              }
          }

        for(n = 0; n < N_gas; n++)
          {
            if(double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0 && double(fabs(P[n].Pos[0]-center_x)) < slice/2.0)
              {

h = fmax(hsml_factor * P[n].Hsml, width / N_grid / 2.0); 
weight = P[n].nh * P[n].nh;

                i = 0;
                j=0;

                i_min = int((P[n].Pos[2]-h-center_z+width/2.0)/width*N_grid);

                if(i_min < 0)
                  {
                    i_min = 0;
                  }

                i_max = int((P[n].Pos[2]+h-center_z+width/2.0)/width*N_grid);

                if(i_max > N_grid-1)
                  {
                    i_max = N_grid-1;
                  }

                j_min = int((P[n].Pos[1]-h-center_y+width/2.0)/width*N_grid);

                if(j_min < 0)
                  {
                    j_min = 0;
                  }

                j_max = int((P[n].Pos[1]+h-center_y+width/2.0)/width*N_grid);

                if(j_max > N_grid-1)
                  {
                    j_max = N_grid-1;
                  }

                do
                  {
                    if(i >= i_min && i <= i_max)
                      {
                        flag_i = 1;

center_i = center_z - width / 2.0 + (i + 0.5) * width / (double) N_grid;

                        do
                          {
                            if(j >= j_min && j <= j_max)
                              {
                                flag_j = 1;

center_j = center_y - width / 2.0 + (j + 0.5) * width / (double) N_grid;

x2 = ((P[n].Pos[2] - center_i) * (P[n].Pos[2] - center_i) + (P[n].Pos[1] -
center_j) * (P[n].Pos[1] - center_j)) / h / h;

if(x2 <= 1.0)
  {
    x = sqrt(x2);

    if(x <= 0.5)
      W_x = 1.0 - 6.0 * x * x + 6.0 * x * x * x;
    else
      W_x = 2.0 * (1.0 - x) * (1.0 - x) * (1.0 - x);

    grid2[i][j] += weight * P[n].H2I * W_x;

    n_grid2[i][j] += weight * W_x;
  }


                                //n_grid2[i][j] += 1;

                                //grid2[i][j] += P[n].nh;
                              }
                            else if(j > j_max)
                              {
                                flag_j = 2;
                              }
                            else
                              {
                                flag_j = 0;
                              }

                             j++;
                           }
                         while((flag_j == 0 || flag_j == 1) && j < N_grid);

                         j = 0;
                       }
                     else if(i > i_max)
                       {
                         flag_i = 2;
                       }
                     else
                       {
                         flag_i = 0;
                       }

                     i++;
                   }
                 while((flag_i == 0 || flag_i == 1) && i < N_grid);

                 i = 0;
               }
           }

        for(i = 0; i < N_grid; i++)
          {
            for(j = 0; j < N_grid; j++)
              {
                if(n_grid2[i][j] > 0)
                  {
                    grid2[i][j] /= double(n_grid2[i][j]);
                  }

                if(grid2[i][j] < min)
                  {
                    grid2[i][j] = min;
                  }

                if(grid2[i][j] > max)
                  {
                    grid2[i][j] = max;
                  }

                grid2[i][j] = log10(grid2[i][j]);
              }
           }

        grid2[0][0] = log10(abs_min);
        grid2[N_grid-1][N_grid-1] = log10(abs_max);

        for(j = 0; j < N_grid; j++)
          {
            grid3[0][j] = log10(min)+(2.0*j+1.0)*(log10(max)-log10(min))/double(N_grid)/2.0;
          }

        grid3[0][0] = log10(abs_min);

        outfile = fopen(buf, "w");

        fwrite(grid1,sizeof(grid1),1,outfile);
        fwrite(grid2,sizeof(grid2),1,outfile);
        fwrite(grid3,sizeof(grid3),1,outfile);
        fwrite(&header.redshift,sizeof(double),1,outfile);
        fwrite(&time_in_Myr,sizeof(double),1,outfile);

        entries = 0.0;

        for(n = 0; n < N_gas; n++)
          {
           if(P[n].sink > 0.5 && P[n].Mass > IDmass)
             {
             IDmass = P[n].Mass;
             IDsink = P[n].Id;
             }
          }


        for(n = 0; n < N_gas; n++)
          {
            if(P[n].sink > 0.5 /*Id[n]*/ /*P[n].Id == IDsink*/  && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                entries++;
              }
          }

        fwrite(&entries,sizeof(double),1,outfile);

        for(n = 0; n < N_gas; n++)
          {
            if(/*P[n].flag_split > 0.5*/  /*Id[n]*/ P[n].Id == IDsink  && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[0]-center_x+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }


        for(n = 0; n < N_gas; n++)
          {
            if(/*P[n].flag_split > 0.5*/  /*Id[n]*/ P[n].Id == 4333881  && P[n].sink > 0.5 && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[0]-center_x+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }

        for(n = 0; n < N_gas; n++)
          {
             if(P[n].sink > 0.5 && /*Id[n]*/  P[n].Id != IDsink  &&  P[n].Id != 4333881 && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[0]-center_x+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }     


        for(n = 0; n < N_gas; n++)
          {
            if(/*P[n].flag_split > 0.5 &&*/ /*Id[n]*/ P[n].Id == IDsink  && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[1]-center_y+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }

       for(n = 0; n < N_gas; n++)
          {
            if(/*P[n].flag_split > 0.5 &&*/ /*Id[n]*/ P[n].Id == 4333881  && P[n].sink > 0.5 && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[1]-center_y+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }

       for(n = 0; n < N_gas; n++)
          {
            if(P[n].sink > 0.5 && /*Id[n]*/ P[n].Id != IDsink  && P[n].Id != 4333881 && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[1]-center_y+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }


        for(n = 0; n < N_gas; n++)
          {
            if(/*P[n].flag_split > 0.5 &&*/  /*Id[n]*/ P[n].Id == IDsink  &&  double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[2]-center_z+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }

//      for(n = 0; n < N_gas; n++)
//          {
 //           if(/*P[n].flag_split > 0.5 &&*/  /*Id[n]*/ P[n].Id == 4333881  && P[n].sink > 0.5 &&  double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
//              {
//                temp_pos = double(int((P[n].Pos[2]-center_z+width/2.0)/width*double(N_grid)))/double(N_grid);

//                fwrite(&temp_pos,sizeof(double),1,outfile);
//              }
//          }


        for(n = 0; n < N_gas; n++)
          {
            if(P[n].sink > 0.5 &&  /*Id[n]*/ P[n].Id != IDsink  && P[n].Id != 4333881 &&  double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[2]-center_z+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }

        fclose(outfile);

        free(P);
      }

    printf("done!\n");
  }
コード例 #8
0
ファイル: g2HIIxz.c プロジェクト: AthenaStacy/gadget_analysis
int main(int argc, char **argv)
  {
    int i = 0;
    int j = 0;
    int n = 0;
    int m = 0;
    int i_min = 0;
    int i_max = 0;
    int j_min = 0;
    int j_max= 0;
    int flag_i = 0;
    int flag_j = 0;
    int N_dm = 0;
    int N_grid = 700;
    int N_begin = 250;
    int N_end = 250;
 //   int n_grid1[N_grid][N_grid];
    double n_grid1[N_grid][N_grid];
    int n_grid2[N_grid][N_grid];

    double center_x = 50.339339267;
    double center_y = 50.121980449;
    double center_z = 49.486589836;

    //double center_x = 50.339110394;
    //double center_y = 50.122129369;
    //double center_z = 49.486652645;

    //double center_x = 1.1711596704;
    //double center_y = 67.550984743;
    //double center_z = 45.119393665;
  
    //double center_x = 70.0;
    //double center_y = 70.0;
    //double center_z = 70.0;

    double width = 140.0;
    double slice = 140.0;
    double entries = 0.0;
    double temp_pos = 0.0;
    double min = 1.0e-4;
    double max = 1.0e-1;
    double abs_min = min;
    double abs_max = max;
    double time_in_Myr = 0.0;
    double grid1[N_grid][N_grid];
    double grid2[N_grid][N_grid];
    double grid3[1][N_grid];
    char dir[500];
    char buf[500];
    FILE *infile;
    FILE *outfile;
   
    double IDmass=0.0;
    int IDsink; 
    double mu, u, h2frac, muh2, muh2in, gamma;   
    int files;
 
    double hsml_factor=1.7;
    double center_i, center_j, W_x, weight, h, x2, x;

    files=1;

    //sprintf(dir, "/work/00863/minerva/tgridsink_ifront_nr6e");
    sprintf(dir, "/work/00863/minerva/ds_nr6e");

    for(m = N_begin; m < N_end+1; m++)
      {
        if(m < 10)
          {
            sprintf(buf, "%s_00%d", dir, m);

            printf("reading 00%d...\n", m);

            N_gas=load_snapshot(buf, files);

            sprintf(buf, "%s_00%d.HIIxz", dir, m);

            printf("processing 00%d...\n", m);
          }
        else if(m > 9 && m < 100)
          {
            sprintf(buf, "%s_0%d", dir, m);

            printf("reading 0%d...\n", m);

            N_gas=load_snapshot(buf, files);

            sprintf(buf, "%s_0%d.HIIxz", dir, m);

            printf("processing 0%d...\n", m);
          }
        else
          {
            sprintf(buf, "%s_%d", dir, m);

            printf("reading %d...\n", m);

            N_gas=load_snapshot(buf, files);

            sprintf(buf, "%s_%d.HIIxz", dir, m);

            printf("processing %d...\n", m);
          }
        
	printf("Point 1\n");

	width= 2.0*2.4e-2*header.HubbleParam/(1.e3*header.time);   
	slice= 2.0*2.4e-2*header.HubbleParam/(1.e3*header.time);  

        //width= 2e0*header.HubbleParam/(1.e3*header.time);
        //slice= 2e0*header.HubbleParam/(1.e3*header.time);

         IDmass = 0.0;
         IDsink = 0;

        for(n = 0; n < N_gas; n++)
          {
              //P[n].nh = P[n].Density*unit_mass/pow(unit_length,3.0)*pow(header.HubbleParam,2.0)/pow(header.time,3.0)*X/m_H;
              //mu = 4.0/(3.0*X+1.0+4.0*X*P[n].elec);
              mu=1.2195;
              h2frac=2.0*P[n].H2I;

              muh2in=(0.24/4.0) + ((1.0-h2frac)*0.76) + (h2frac*.76/2.0);
              muh2=pow(muh2in, -1.0);

              if(muh2 >= 1.22){
                 mu=muh2;
                }

              gamma = P[n].gam;
   
              P[n].Temp = P[n].EgySpec*unit_energy/unit_mass*mu*(gamma-1.0)*m_H/k_B;
              P[n].nh = P[n].Density*unit_mass/pow(unit_length,3.0)*pow(header.HubbleParam,2.0)/pow(header.time,3.0)*X/m_H;             
          }

        printf("HII= %lg \n", P[100].HII);

        time_in_Myr = 2.0/3.0/Hubble/header.HubbleParam/sqrt(header.Omega0)*pow(header.time,3.0/2.0)/1.0e6/yr;

        flag_i = 0;
        flag_j = 0;

        for(i = 0; i < N_grid; i++)
          {
            for(j = 0; j < N_grid; j++)
              {
                n_grid1[i][j] = 0;

                grid1[i][j] = 0.0;
              }
          }
	printf("Point 2\n");
        for(n = 0; n < N_gas; n++)
          {
            if(fabs(P[n].Pos[0]-center_x) < width/2.0 && fabs(P[n].Pos[1]-center_y) < width/2.0 && fabs(P[n].Pos[2]-center_z) < width/2.0 && fabs(P[n].Pos[2]-center_z) < slice/2.0)
              {

h = fmax(hsml_factor * P[n].Hsml, width / N_grid / 2.0);
weight = P[n].nh * P[n].nh;

if(P[n].sink > 0)
  h = hsml_factor * 3.57101e-07;


                i = 0;
                j=0;

                i_min = int((P[n].Pos[0]-h-center_x+width/2.0)/width*N_grid);

                if(i_min < 0)
                  {
                    i_min = 0;
                  }

                i_max = int((P[n].Pos[0]+h-center_x+width/2.0)/width*N_grid);

                if(i_max > N_grid-1)
                  {
                    i_max = N_grid-1;
                  }

                j_min = int((P[n].Pos[2]-h-center_z+width/2.0)/width*N_grid);

                if(j_min < 0)
                  {
                    j_min = 0;
                  }

                j_max = int((P[n].Pos[2]+h-center_z+width/2.0)/width*N_grid);

                if(j_max > N_grid-1)
                  {
                    j_max = N_grid-1;
                  }

                do
                  {
                    if(i >= i_min && i <= i_max)
                      {
                        flag_i = 1;

center_i = center_x - width / 2.0 + (i + 0.5) * width / (double) N_grid;

                        do
                          {
                            if(j >= j_min && j <= j_max)
                              {
                                flag_j = 1;

center_j = center_z - width / 2.0 + (j + 0.5) * width / (double) N_grid;

x2 = ((P[n].Pos[0] - center_i) * (P[n].Pos[0] - center_i) + (P[n].Pos[2] -
center_j) * (P[n].Pos[2] - center_j)) / h / h;

if(x2 <= 1.0)
  {
    x = sqrt(x2);

    if(x <= 0.5)
      W_x = 1.0 - 6.0 * x * x + 6.0 * x * x * x;
    else
      W_x = 2.0 * (1.0 - x) * (1.0 - x) * (1.0 - x);

    grid1[i][j] += weight * P[n].HII * W_x;

    n_grid1[i][j] += weight * W_x;
  }



                              }
                            else if(j > j_max)
                              {
                                flag_j = 2;
                              }
                            else
                              {
                                flag_j = 0;
                              }

                             j++;
                           }
                         while((flag_j == 0 || flag_j == 1) && j < N_grid);

                         j = 0;
                       }
                     else if(i > i_max)
                       {
                         flag_i = 2;
                       }
                     else
                       {
                         flag_i = 0;
                       }

                     i++;
                   }
                 while((flag_i == 0 || flag_i == 1) && i < N_grid);

                 i = 0;
               }
           }
	printf("Point 3\n");
        for(i = 0; i < N_grid; i++)
          {
            for(j = 0; j < N_grid; j++)
              {
                if(n_grid1[i][j] > 0)
                  {
                    grid1[i][j] /= double(n_grid1[i][j]);
                  }

                if(grid1[i][j] < min)
                  {
                    grid1[i][j] = min;
                  }

                if(grid1[i][j] > max)
                  {
                    grid1[i][j] = max;
                  }

                grid1[i][j] = log10(grid1[i][j]);
              }
           }

        grid1[0][0] = log10(abs_min);
        grid1[N_grid-1][N_grid-1] = log10(abs_max);

        flag_i = 0;
        flag_j = 0;
	printf("Point 4\n");
        for(i = 0; i < N_grid; i++)
          {
            for(j = 0; j < N_grid; j++)
              {
                n_grid2[i][j] = 0;

                grid2[i][j] = 0.0;
              }
          }
	printf("Point 5\n");
        for(n = 0; n < N_gas; n++)
          {
            if(fabs(P[n].Pos[0]-center_x) < width/2.0 && fabs(P[n].Pos[1]-center_y) < width/2.0 && fabs(P[n].Pos[2]-center_z) < width/2.0 && fabs(P[n].Pos[0]-center_x) < slice/2.0)
              {
                i = 0;
                j=0;

                i_min = int((P[n].Pos[2]-h-center_z+width/2.0)/width*N_grid);

                if(i_min < 0)
                  {
                    i_min = 0;
                  }

                i_max = int((P[n].Pos[2]+h-center_z+width/2.0)/width*N_grid);

                if(i_max > N_grid-1)
                  {
                    i_max = N_grid-1;
                  }

                j_min = int((P[n].Pos[1]-h-center_y+width/2.0)/width*N_grid);

                if(j_min < 0)
                  {
                    j_min = 0;
                  }

                j_max = int((P[n].Pos[1]+h-center_y+width/2.0)/width*N_grid);

                if(j_max > N_grid-1)
                  {
                    j_max = N_grid-1;
                  }

                do
                  {
                    if(i >= i_min && i <= i_max)
                      {
                        flag_i = 1;

                        do
                          {
                            if(j >= j_min && j <= j_max)
                              {
                                flag_j = 1;

                                n_grid2[i][j] += 1;

                                grid2[i][j] += P[n].HII;
                              }
                            else if(j > j_max)
                              {
                                flag_j = 2;
                              }
                            else
                              {
                                flag_j = 0;
                              }

                             j++;
                           }
                         while((flag_j == 0 || flag_j == 1) && j < N_grid);

                         j = 0;
                       }
                     else if(i > i_max)
                       {
                         flag_i = 2;
                       }
                     else
                       {
                         flag_i = 0;
                       }

                     i++;
                   }
                 while((flag_i == 0 || flag_i == 1) && i < N_grid);

                 i = 0;
               }
           }
	printf("Point 6\n");
        for(i = 0; i < N_grid; i++)
          {
            for(j = 0; j < N_grid; j++)
              {
                if(n_grid2[i][j] > 0)
                  {
                    grid2[i][j] /= double(n_grid2[i][j]);
                  }

                if(grid2[i][j] < min)
                  {
                    grid2[i][j] = min;
                  }

                if(grid2[i][j] > max)
                  {
                    grid2[i][j] = max;
                  }

                grid2[i][j] = log10(grid2[i][j]);
              }
           }

        grid2[0][0] = log10(abs_min);
        grid2[N_grid-1][N_grid-1] = log10(abs_max);

        for(j = 0; j < N_grid; j++)
          {
            grid3[0][j] = log10(min)+(2.0*j+1.0)*(log10(max)-log10(min))/double(N_grid)/2.0;
          }

        grid3[0][0] = log10(abs_min);

        outfile = fopen(buf, "w");

        fwrite(grid1,sizeof(grid1),1,outfile);
        fwrite(grid2,sizeof(grid2),1,outfile);
        fwrite(grid3,sizeof(grid3),1,outfile);
        fwrite(&header.redshift,sizeof(double),1,outfile);
        fwrite(&time_in_Myr,sizeof(double),1,outfile);

        entries = 0.0;
	printf("Point 7\n");

	/*
       for(n = 1; n <= N_gas; n++)
          {
            if(P[n].flag_split > 0.5 (Id[n] == 4025757 || Id[n] == 3410514 || Id[n] == 4014428) && fabs(P[n].Pos[0]-center_x) < width/2.0 && fabs(P[n].Pos[1]-center_y) < width/2.0 && fabs(P[n].Pos[2]-center_z) < width/2.0)
              {
                entries++;
              }
          }

        fwrite(&entries,sizeof(double),1,outfile);

        for(n = 1; n <= N_gas; n++)
          {
            if(P[n].flag_split > 0.5 (Id[n] == 4025757 || Id[n] == 3410514 || Id[n] == 4014428) && fabs(P[n].Pos[0]-center_x) < width/2.0 && fabs(P[n].Pos[1]-center_y) < width/2.0 && fabs(P[n].Pos[2]-center_z) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[0]-center_x+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }

        for(n = 1; n <= N_gas; n++)
          {
            if(P[n].flag_split > 0.5 (Id[n] == 4025757 || Id[n] == 3410514 || Id[n] == 4014428) && fabs(P[n].Pos[0]-center_x) < width/2.0 && fabs(P[n].Pos[1]-center_y) < width/2.0 && fabs(P[n].Pos[2]-center_z) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[1]-center_y+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }

        for(n = 1; n <= N_gas; n++)
          {
            if(P[n].flag_split > 0.5 (Id[n] == 4025757 || Id[n] == 3410514 || Id[n] == 4014428)  && fabs(P[n].Pos[0]-center_x) < width/2.0 && fabs(P[n].Pos[1]-center_y) < width/2.0 && fabs(P[n].Pos[2]-center_z) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[2]-center_z+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }
   */

        for(n = 0; n < N_gas; n++)
          {
           if(P[n].sink > 0.5 && P[n].Mass > IDmass)
             {
             IDmass = P[n].Mass;
             IDsink = P[n].Id;
             }
          } 


     for(n = 0; n < N_gas; n++)
          {            if(P[n].sink > 0.5 /*Id[n]*/ /*P[n].Id == IDsink*/  && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                entries++;
              } 
          }
    
        fwrite(&entries,sizeof(double),1,outfile);
    
        for(n = 0; n < N_gas; n++)
          {
            if(/*P[n].flag_split > 0.5*/  /*Id[n]*/ P[n].Id == IDsink  && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[0]-center_x+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }


        for(n = 0; n < N_gas; n++)
          {
            if(/*P[n].flag_split > 0.5*/  /*Id[n]*/ P[n].Id == 4333881  && P[n].sink > 0.5 && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[0]-center_x+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }

        for(n = 0; n < N_gas; n++)
          {
             if(P[n].sink > 0.5 && /*Id[n]*/  P[n].Id != IDsink  &&  P[n].Id != 4333881 && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[0]-center_x+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }

      for(n = 0; n < N_gas; n++)
          {
            if(/*P[n].flag_split > 0.5 &&*/ /*Id[n]*/ P[n].Id == IDsink  && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[1]-center_y+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }

       for(n = 0; n < N_gas; n++)
          {
            if(/*P[n].flag_split > 0.5 &&*/ /*Id[n]*/ P[n].Id == 4333881  && P[n].sink > 0.5 && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[1]-center_y+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }

       for(n = 0; n < N_gas; n++)
          {
            if(P[n].sink > 0.5 && /*Id[n]*/ P[n].Id != IDsink  && P[n].Id != 4333881 && double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[1]-center_y+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }


      for(n = 0; n < N_gas; n++)
          {
            if(/*P[n].flag_split > 0.5 &&*/  /*Id[n]*/ P[n].Id == IDsink  &&  double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[2]-center_z+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }

      for(n = 0; n < N_gas; n++)
          {
            if(/*P[n].flag_split > 0.5 &&*/  /*Id[n]*/ P[n].Id == 4333881  && P[n].sink > 0.5 &&  double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[2]-center_z+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }


        for(n = 0; n < N_gas; n++)
          {
            if(P[n].sink > 0.5 &&  /*Id[n]*/ P[n].Id != IDsink  && P[n].Id != 4333881 &&  double(fabs(P[n].Pos[0]-center_x)) < width/2.0 && double(fabs(P[n].Pos[1]-center_y)) < width/2.0 && double(fabs(P[n].Pos[2]-center_z)) < width/2.0)
              {
                temp_pos = double(int((P[n].Pos[2]-center_z+width/2.0)/width*double(N_grid)))/double(N_grid);

                fwrite(&temp_pos,sizeof(double),1,outfile);
              }
          }

	printf("Point 10\n");
        fclose(outfile);
	printf("Point 11\n");
        free(P);
      }

    printf("done!\n");
  }
コード例 #9
0
ファイル: read.c プロジェクト: surftour/astrotools
/* Here we load a snapshot file. It can be distributed
 * onto several files (for files>1).
 * The particles are brought back into the order
 * implied by their ID's.
 * A unit conversion routine is called to do unit
 * conversion, and to evaluate the gas temperature.
 */
int main(int argc, char **argv)
{
  char input_fname[200];
  int  type, files, i, ok;
  int  quiteon= 0;
  char *p;

  if(argc<2)
    {
      printf("\n>readsnap <filename> <[option]>\n\n");
      printf("options\n");
      printf("-------\n");
      printf(" -info   prints byte information for all fields present\n");
      printf(" -h      only the header information is printed to the screen\n");
      printf(" -m      prints the mass of a particle when displaying other information\n");
      printf(" -id     prints the ID for each particle.\n");
      printf(" -pot    prints the Potential for every particle.\n");
      printf(" -tm     prints the total mass of each type\n");
      printf(" -gm     prints the gas mass\n");
      printf("\n\n");
      exit(0);
    }

  files=1;                               /* number of files per snapshot */
  ShowHeader=0;
  ShowMass=0;
  ShowId=0;
  ShowPot=0;
  Reorder=0;
  PrintDefault=0;
  SnapFile=0;

  strcpy(input_fname, argv[1]);

  /* problem, what if we give a path rather then just filename 
  if(!strncmp(input_fname, "snapshot", 8))  SnapFile = 1; */
  if(strstr(input_fname,"snapshot")!=0)  SnapFile = 1;

  if(argc==2) PrintDefault = 1;

  for(i=2; i<argc; i++)
  {
	ok = 0;
	if(!(strcmp(argv[i],"-info"))) ok = SnapInfo = 1;
	if(!(strcmp(argv[i],"-h"))) ok = ShowHeader = 1;
	if(!(strcmp(argv[i],"-tm"))) ok = PrintTotalMass =1;
	if(!(strcmp(argv[i],"-gm"))) ok = PrintGasMass = quiteon= 1;
	if(!(strcmp(argv[i],"-m"))) PrintDefault = ShowMass = 1;
	if(!(strcmp(argv[i],"-id"))) PrintDefault = ShowId = 1;
	if(!(strcmp(argv[i],"-pot"))) PrintDefault = ShowPot = 1;

	if((ok==0) && (PrintDefault==0))
	{
		printf("Unknown parameter: %s\n",argv[i]);
		printf("Please use correct parameters.\n");
		exit(0); 
	}
  }


  ok= load_snapshot(input_fname, files, quiteon, ShowHeader);

  if(Reorder) reordering();  /* call this routine only if your ID's are set properly */

  if(!ShowHeader) unit_conversion();  /* optional stuff */

  if(PrintDefault) write_std_to_file();
  if(ShowHeader) write_header();
  if(PrintTotalMass) print_totalmass();
  if(PrintGasMass) print_gasmass();

  return(0);
}
コード例 #10
0
ファイル: mergtree.c プロジェクト: jpcoles/tip2gad
/* Here we load a snapshot file. It can be distributed
 * onto several files (for files>1).
 * The particles are brought back into the order
 * implied by their ID's.
 * A unit conversion routine is called to do unit
 * conversion, and to evaluate the gas temperature.
 */
int main(int argc, char **argv)
{
    char dir[256];
    char *snapshot_fname = NULL, 
         *fof_fname = NULL, 
         *groups_fname = NULL,
         *gmap_fname = NULL;
    int  files;
    float fPeriodf1,fPeriodf2,fPeriodf3,fEpsf;
    int i,nf;
    int *pmap; /* A map between a particle and the group it is in */
    int nGroups, nMapGroups, Ngroups;
    group_t *groups;
    gmap_t *gmap;

    int mode = DO_NOTHING;

    /*=======================================================================
     * Parse command line arguments
     *=====================================================================*/
    for (i=1; i < argc; i++)
    {
        if (!strcmp("--make-fof", argv[i]))
        {
            if (mode != DO_NOTHING) help();
            if (++i < argc) snapshot_fname = argv[i]; else help();
            if (++i < argc) fof_fname = argv[i]; else help();
            mode = MAKE_FOF;
        }
        else if (!strcmp("--make-groups", argv[i]))
        {
            if (mode != DO_NOTHING) help();
            if (++i < argc) snapshot_fname = argv[i]; else help();
            if (++i < argc) fof_fname      = argv[i]; else help();
            mode = MAKE_GROUPS;
        }
        else if (!strcmp("--make-tree", argv[i]))
        {
            if (mode != DO_NOTHING) help();
            if (++i < argc) groups_fname   = argv[i]; else help();
            if (++i < argc) snapshot_fname = argv[i]; else help();
            if (++i < argc) fof_fname      = argv[i]; else help();
            if (++i < argc) gmap_fname     = argv[i]; else help();
            mode = MAKE_TREE;
        }
        else if (!strcmp("-M", argv[i]))
        {
            if (++i < argc) MassMin = atof(argv[i]); else help();
            if (++i < argc) MassMax = atof(argv[i]); else help();
        }
        else if (!strcmp("-nmin", argv[i]))
        {
            if (++i < argc) nMin = atof(argv[i]); else help();
        }
    }

    /*=======================================================================
     * Check that the user gave us sensible parameters
     *=====================================================================*/
    if (mode == DO_NOTHING) help();

    /*=======================================================================
     * Load in the snapshot (GADGET format)
     *=====================================================================*/
    files=1;                               /* number of files per snapshot */
    fprintf(stderr, "Loading snapshot %s.\n", snapshot_fname);
    load_snapshot(snapshot_fname, files);

    printf("Npart: %d; Time: %lf; Redshift: %lf\n",NumPart,header1.time, header1.redshift);

    nf=NumPart;
    printf("First particle:  %f %f %f \n",P[1].Pos[0],P[1].Pos[1],P[1].Pos[2]);
    printf("Medium particle: %f %f %f \n",P[nf/2].Pos[0],P[nf/2].Pos[1],P[nf/2].Pos[2]);
    printf("Last particle:   %f %f %f \n",P[nf].Pos[0],P[nf].Pos[1],P[nf].Pos[2]);
  

    /*=======================================================================
     * Prepare to either create or load the FOF data
     *=====================================================================*/
    fEpsf =  header1.BoxSize/ pow( NumPart, 1./3.);
    printf("Distanza interparticellare media: %f\n",fEpsf);
    fEpsf *= 0.2; 
/*  fEpsf *= 0.15; */
/*  fEpsf *= 0.1; */
    fPeriodf1=fPeriodf2=fPeriodf3=(float) header1.BoxSize;
    pmap=malloc((NumPart+1)*sizeof(int));
    if(pmap==NULL) 
    { 
        printf("Errore di allocazione memoria indici.\n");
        exit(-1); 
    }

    /* LE UNITA' NATURALI GADGET LAVORANO IN 10^10 MSOL. SE SONO STATE 
    CAMBIATE, OCCORRE MODIFICARE QUI */

    if (MassMin != -1 && MassMax != -1) 
    { 
        fprintf(stderr, "Mass range: [%2.2e,%2.2e]\n", MassMin, MassMax);
        MassMin /= UdM; MassMax /= UdM; 
    }
    else
    {
        fprintf(stderr, "Mass range: Unbounded\n");
        MassMin = 0;
        MassMax = 1e33;
    }

    switch (mode)
    {
        case MAKE_FOF:
            fprintf(stderr, "Making FOFs.\n");
            fof_(fEpsf,fPeriodf1,fPeriodf2,fPeriodf3,NumPart,P,pmap);
            write_pmap(fof_fname, fEpsf,fPeriodf1,fPeriodf2,fPeriodf3,NumPart,pmap);
            break;

        case MAKE_GROUPS:
            fprintf(stderr, "Making Groups.\n");
            if (read_pmap(fof_fname, fEpsf,fPeriodf1,fPeriodf2,fPeriodf3,NumPart,pmap))
                exit(1);
            EvalGroups0(pmap,snapshot_fname);
            break;

        case MAKE_TREE:
            fprintf(stderr, "Making Progenitor Trees.\n");
            if (read_groups(groups_fname, &groups, &nGroups)) exit(1);
            if (read_gmap(gmap_fname, &gmap, &nMapGroups))    exit(1);

            /*=======================================================================
             * Sanity check that the group files match up.
             *=====================================================================*/
#if 0
            if (nGroups != nMapGroups)
            {
                fprintf(stderr, 
                    "Mismatched number of groups between group and map files (%i != %i).\n",
                    nGroups, nMapGroups);
                exit(1);
            }
#endif

#if 0
            int nPartInGroups=0, nPartInMap=0;
            for (i=0; i < nGroups; i++)
            {
                nPartInGroups += groups[i].npart;
                nPartInMap    += gmap[i].npart;
            }

            fprintf(stderr, "HERE 4\n");

            if (nGroups != nMapGroups)
            {
                fprintf(stderr, "Mismatched number of particles between group and map files.\n");
                exit(1);
            }
#endif

            /*=======================================================================
             * Now load the particle->group map.
             *=====================================================================*/
            if (read_pmap(fof_fname, fEpsf,fPeriodf1,fPeriodf2,fPeriodf3,NumPart,pmap))
                exit(1);


            //sonidx=malloc( (NumPart+1)*sizeof(int));
            //npson=load_son_idx(sonidx, index_fname);
            //if(npson <= 0) { printf("ERROR: group non find.\n"); exit(-1); }
            //printf("<<Son>> group with %d particles loaded.\n",npson);


            mkdir("GROUPS", -1);
            assert(!chdir("GROUPS"));
            Ngroups = EvalGroups1(pmap);
            chdir("..");

            gmap_t *gmap2 = (gmap_t *)calloc(Ngroups+1, sizeof(gmap_t));
            for (i=1; i < NumPart+1; i++)
                gmap2[pmap[i]].npart++;

            for (i=0; i < Ngroups+1; i++)
            {
                gmap2[i].ps = (int *)malloc(gmap2[i].npart * sizeof(int));
                assert(gmap2[i].ps != NULL);
                gmap2[i].npart = 0;
            }

            for (i=1; i < NumPart+1; i++)
            {
                gmap2[pmap[i]].ps[ gmap2[pmap[i]].npart++ ] = i;
            }
#if 1

            printf("Finding progenitors with mass %%: %f\n",PROGPERC);

            for (i=0; i < nGroups; i++)
            {

                //fprintf(stderr, "Group %i [Mass: %f]\n", i, groups[i].Mass);
#if 1
                if (MassMin != -1 && MassMax != -1)
                {
                    if (!(MassMin < groups[i].Mass && groups[i].Mass < MassMax))
                    {
                        fprintf(stderr, "Outside mass range.  Group %i/%i.\n", i+1, nGroups+1);;
                        continue;
                    }
                }

                snprintf(dir, 256, "%05i", groups[i].id);
                fprintf(stderr, "Making directory %s. Group %i/%i.\n", dir, i+1, nGroups+1);;
                mkdir(dir, -1);
                assert(!chdir(dir));

                int *ps = NULL;
                int npart = 0;
                int j;
                for (j=0; j < nMapGroups; j++)
                {
                    if (groups[i].id == gmap[j].gid)
                    {
                        assert(ps == NULL);
                        ps    = gmap[j].ps;
                        npart = gmap[j].npart;

                        assert(groups[i].npart == gmap[j].npart);

                        /* Intentionally not breaking here to check the assert()'ion if there
                         * is somehow a duplicate groups. */
                    }
                }

                assert(ps != NULL);

                EvalProgenitors(snapshot_fname, pmap, ps, npart, Ngroups, gmap2, Ngroups);
                
                chdir("..");
#endif
            }
#endif
            break;

        default:
            fprintf(stderr, "Unknown internal mode: %i\n", mode);
            exit(1);
    }

    return 0;
}
コード例 #11
0
ファイル: disk.c プロジェクト: AthenaStacy/gadget_analysis
/* Here we load a snapshot file. It can be distributed
 * onto several files (for files>1).
 * The particles are brought back into the order
 * implied by their ID's.
 * A unit conversion routine is called to do unit
 * conversion, and to evaluate the gas temperature.
 */
int main(int argc, char **argv)
{
  char path[200], input_fname[200], output_fname[200], basename[200], basenameout[200];
  int  i, k=0, j, n, type, snapshot_number, files, Ngas, random, ncount, ncounthalo1, ncount2, halo;
  double x,y,z,x1,y1,z1, delr;
  double nh, nhmax, mass, mmax, dis, disAU, xmax, ymax, zmax, sl, masstot, temp, tmax, h2, h2max, gam, gammin;
  double kB, G;
  double massHIT, diskmass, massin=0.0, massout=0.0;
  double mass_sink1, mass_sink2, mass_sink3, mass_sink4, mass_tot;
  double dis12, dis13, x_com, y_com, z_com, vx_com, vy_com, vz_com, vx1, vy1, vz1, vx2, vy2, vz2, vx3, vy3, vz3, vx4, vy4, vz4;
  double sinkposx1, sinkposy1, sinkposz1, sinkposx2, sinkposy2, sinkposz2, sinkposx3, sinkposy3, sinkposz3, sinkposx4, sinkposy4, sinkposz4;
  double num, numz, tempz, vz, rhoz, amom, amomtot, amomtotx, amomtoty, amomtotz, amomx, amomy, amomz, amomx1, amomx2, amomy1, amomy2, amomz1, amomz2;
  double xfac, vrad, vrot, vrotx, vroty, vrotz, omega, nh_avg, temp_avg, vrad_avg, vrot_avg, omega_avg, num_tot;
  double xtimesm, ytimesm, ztimesm, vxtimesm, vytimesm, vztimesm;
  double xCOM, yCOM, zCOM, vxCOM, vyCOM, vzCOM, jzcent, jnum;
  double m_enc_arr[200], d_arr[200], mass_enc;
  int ID_sink1, ID_sink2, ID_sink3, ID_sink4, sinknum;
  FILE *outfile;
  FILE *outfile2;


  sprintf(path, "/nobackupp1/astacy/hires");
  //sprintf(path, "/nobackupp1/astacy/");
  //sprintf(path, "/nobackupp1/astacy/binHR");

  halo = 0;

    if(halo == 0)
     {
     //sprintf(basename, "hires_test10");
     sprintf(basename, "hires_test10b");
     sprintf(basename, "hires3");
     sprintf(basenameout, "snaphires_test10");
     //jnum = 228;
     jnum = 2;
     }
  if(halo == 1)
     {
     sprintf(basename, "bin_HR1");
     sprintf(basenameout, "snapbin_HR1");
     //jnum = 228;
     jnum = 6;
     }
  if(halo == 2)
     {
     sprintf(basename, "bin_HR2");
     sprintf(basenameout, "snapbin_HR2");
     //jnum = 207;
     jnum = 5;
     }
  if(halo == 3)
     {
     sprintf(basename, "bin_HR3");
     sprintf(basenameout, "snapbin_HR3");
     //jnum = 206;
     jnum = 7;
     }
  if(halo == 4)
     {
     sprintf(basename, "bin_HR4");
     sprintf(basenameout, "snapbin_HR4");
     //jnum = 204;
     jnum = 7;
     }
  if(halo == 5)
     {
     sprintf(basename, "bin_HR5");
     sprintf(basenameout, "snapbin_HR5");
     //jnum = 209;
     jnum = 7;
     }
  if(halo == 6)
     {
     sprintf(basename, "bin_HR6");
     sprintf(basenameout, "snapbin_HR6b");
     //jnum = 224;
     jnum = 7;
     }
  if(halo == 7)
     {
     sprintf(basename, "bin_HR7b");
     sprintf(basenameout, "snapbin_HR7b");
     //jnum = 655;
     jnum = 9;
     //jnum=38;
     }
  if(halo == 8)
     {
     sprintf(basename, "bin_HR8");
     sprintf(basenameout, "snapbin_HR8");
     //jnum = 219;
     jnum = 7;
     }
  if(halo == 9)
     {
     sprintf(basename, "bin_HR9");
     sprintf(basenameout, "snapbin_HR9");
     //jnum = 207;
     jnum = 5;
     }
  if(halo == 10)
     {
     //sprintf(basename, "bin_HR10");
     sprintf(basename, "bin_HR10_alt");
     sprintf(basenameout, "snapbin_HR10");
     //jnum = 241;
     //jnum = 7;
     jnum=8;
     //jnum = 24;
     }


  for(j=2;j<=50;j=j+1){
  //for(j=jnum;j<=jnum;j=j+100){

  snapshot_number= j;                   /* number of snapshot */
  files=1;                               /* number of files per snapshot */

  kB = 1.38e-16;
  G = 6.67e-8;
  diskmass = 0.0;

  sprintf(input_fname, "%s/%s_%03d", path, basename, snapshot_number);
  sprintf(output_fname, "%s_disk.dat",basename);
  Ngas = load_snapshot(input_fname, files);

  ID_sink1 = 4352905;
  ID_sink2 = 4333881;
  sinknum = 0;
          /*    reordering();*/ /* call this routine only if your ID's are set properly */

printf("hello line 187\n");

          unit_conversion();

printf("hello line 191\n");

          nh_avg= vrad_avg = vrot_avg = omega_avg = 0;

printf("hello line 195\n");

          temp_avg=0;
          num_tot=0;
          h2max=0;
          masstot=0;
          mmax=0;
          xtimesm = 0.0;
          ytimesm = 0.0;
          ztimesm = 0.0;
          vxtimesm = 0.0;
          vytimesm = 0.0;
          vztimesm = 0.0;


             for(i = 0; i < Ngas; i++)
                {
                if(Id[i] == ID_sink1)
                  {
                  sinkposx1 = P[i].Pos[0];
                  sinkposy1 = P[i].Pos[1];
                  sinkposz1 = P[i].Pos[2];
                  vx1 = P[i].Vel[0];
                  vy1 = P[i].Vel[1];
                  vz1 = P[i].Vel[2];
                  mass_sink1 = P[i].Mass*1.e10/0.7;
                  printf("Found the sink! mass= %lg, nh = %lg\n", mass_sink1, P[i].nh);
                  }

                 if(P[i].nh > 1e9)
                  {
                  diskmass = diskmass + (P[i].Mass*1.e10/0.7);
                  xtimesm = xtimesm + P[i].Pos[0]*(P[i].Mass*1.e10/0.7);
                  ytimesm = ytimesm + P[i].Pos[1]*(P[i].Mass*1.e10/0.7);
                  ztimesm = ztimesm + P[i].Pos[2]*(P[i].Mass*1.e10/0.7);
                  vxtimesm = vxtimesm + P[i].Vel[0]*(P[i].Mass*1.e10/0.7);
                  vytimesm = vytimesm + P[i].Vel[1]*(P[i].Mass*1.e10/0.7);
                  vztimesm = vztimesm + P[i].Vel[2]*(P[i].Mass*1.e10/0.7);
                  }
                }

             xCOM = xtimesm/diskmass;
             yCOM = ytimesm/diskmass;
             zCOM = ztimesm/diskmass;
             vxCOM = vxtimesm/diskmass;
             vyCOM = vytimesm/diskmass;
             vzCOM = vztimesm/diskmass;
             printf("%15.11g %15.11g %15.11g\n", xCOM, yCOM, zCOM);
             printf("%15.11g %15.11g %15.11g\n", vxCOM, vyCOM, vzCOM);


          //  if(j>=4)
          //  {
            sinkposx1 = xCOM;
            sinkposy1 = yCOM;
            sinkposz1 = zCOM;
            mass_sink1 = diskmass;
            vx1 = vxCOM;
            vy1 = vyCOM;
            vz1 = vzCOM;
         //   }

         diskmass=0.0;
         ncount=0;

        for(n=0; n<200; n++)
               {
               m_enc_arr[n] = 0.0;
               d_arr[n] = (double(n)/199.0)*10000.0;
               printf("d_arr[%d] = %lg\n", n, d_arr[n]);
               }

       for(i = 0; i < Ngas; i++)
               {
                if(P[i].nh > 1.e8)
                  {
                   dis = pow(((P[i].Pos[0]-sinkposx1)*(P[i].Pos[0]-sinkposx1) + (P[i].Pos[1]-sinkposy1)*(P[i].Pos[1]-sinkposy1) + (P[i].Pos[2]-sinkposz1)*(P[i].Pos[2]-sinkposz1)), 0.5);
                   dis=dis*1.e3*Time/(0.7);                   //dis is in pc
                   disAU = dis*206264.8060;
                   for(n=0; n<200; n++)
                     {
                     if(disAU < d_arr[n] /*|| P[i].sink > 0.5*/)
                       m_enc_arr[n] = m_enc_arr[n] + P[i].Mass*1.e10/0.7;
                     }
                    }
                  }

        for(n=0; n<200; n++)
               {
               printf("m_enc_arr[%d] = %lg\n", n, m_enc_arr[n]);
               }


         for(i = 0; i < Ngas; i++)
                {

                 P[i].Vel[0] = P[i].Vel[0] - vx1;
                 P[i].Vel[1] = P[i].Vel[1] - vy1;
                 P[i].Vel[2] = P[i].Vel[2] - vz1;

                 amomx = (P[i].Pos[1]-sinkposy1)*P[i].Vel[2]  - (P[i].Pos[2]-sinkposz1)*P[i].Vel[1];
                 amomy = (P[i].Pos[2]-sinkposz1)*P[i].Vel[0] - (P[i].Pos[0]-sinkposx1)*P[i].Vel[2];
                 amomz = (P[i].Pos[0]-sinkposx1)*P[i].Vel[1]  -  (P[i].Pos[1]-sinkposy1)*P[i].Vel[0];

                 amomx =  amomx*pow(Time, 0.5)*1.e5*3.086e18*1.e3*Time/(0.7);  //convert to cgs units
                 amomy =  amomy*pow(Time, 0.5)*1.e5*3.086e18*1.e3*Time/(0.7);
                 amomz =  amomz*pow(Time, 0.5)*1.e5*3.086e18*1.e3*Time/(0.7);

                 amom = pow(amomx*amomx + amomy*amomy + amomz*amomz, 0.5);

                 dis = pow(((P[i].Pos[0]-sinkposx1)*(P[i].Pos[0]-sinkposx1) + (P[i].Pos[1]-sinkposy1)*(P[i].Pos[1]-sinkposy1) + (P[i].Pos[2]-sinkposz1)*(P[i].Pos[2]-sinkposz1)), 0.5);
                 //dis = pow(((P[i].Pos[0]-sinkposx1)*(P[i].Pos[0]-sinkposx1) + (P[i].Pos[2]-sinkposz1)*(P[i].Pos[2]-sinkposz1)), 0.5);
                 dis=dis*1.e3*Time/(0.7);                   //dis is in pc
                 disAU = dis*206264.8060;
                 dis=dis*3.086e18;   //dis in now in cm                

                 vrad =  (P[n].Vel[0]*(P[n].Pos[0]-sinkposx1) + P[n].Vel[1]*(P[n].Pos[1]-sinkposy1) + P[n].Vel[2]*(P[n].Pos[2]-sinkposz1))/pow(((P[n].Pos[0]-sinkposx1)*(P[n].Pos[0]-sinkposx1) + (P[n].Pos[1]-sinkposy1)*(P[n].Pos[1]-sinkposy1) + (P[n].Pos[2]-sinkposz1)*(P[n].Pos[2]-sinkposz1)), 0.5);
                 vrad = vrad*pow(Time, 0.5);


                 vrotx = (P[n].Pos[1]-sinkposy1)*P[n].Vel[2]  - (P[n].Pos[2]-sinkposz1)*P[n].Vel[1];
                 vroty = (P[n].Pos[2]-sinkposz1)*P[n].Vel[0] - (P[n].Pos[0]-sinkposx1)*P[n].Vel[2];
                 vrotz = (P[n].Pos[0]-sinkposx1)*P[n].Vel[1]  -  (P[n].Pos[1]-sinkposy1)*P[n].Vel[0];

                 vrot = pow(vrotx*vrotx + vroty*vroty + vrotz*vrotz, 0.5);
                 vrot = vrot*pow(Time, 0.5)/pow(((P[n].Pos[0]-sinkposx1)*(P[n].Pos[0]-sinkposx1) + (P[n].Pos[1]-sinkposy1)*(P[n].Pos[1]-sinkposy1) + (P[n].Pos[2]-sinkposz1)*(P[n].Pos[2]-sinkposz1)), 0.5);

                 omega = vrot/(dis/1.e5);  // pi factors CANCEL OUT -- 2 pi r to get circumference CANCELS with the 2 pi radians per circumference

                 if(P[i].nh > 1.e8)
                 {
                   mass_enc = m_enc_arr[0];
                   for(n=0; n<200; n++)
                     {
                     if(disAU > d_arr[n])
                       mass_enc = m_enc_arr[n];
                     }
                 //jzcent = pow(6.67e-8 * mass_sink1 * 1.98892e33*dis, 0.5);
                 jzcent = pow(6.67e-8 * mass_enc * 1.98892e33*dis, 0.5);
                 }

                 //if((fabs(amom - jzcent) <= 0.5*jzcent && P[i].nh > 1.e8) && P[i].sink < 0.5)
                 //if((fabs(amom - jzcent) <= 0.5*jzcent && P[i].nh > 1.e8) || P[i].sink > 0.5)
                 if(P[i].nh > 1.e9 && P[i].H2I > 1.e-3 || P[i].sink > 0.5)
                 //if(P[i].nh > 1.e9 && P[i].H2I > 1.e-3 && P[i].sink < 0.5)
                 //if(P[i].nh > 1.e9 && P[i].H2I <= 1.e-3 &&  P[i].sink < 0.5)
                 //if(amom > jzcent && P[i].nh > 1.e8 && P[i].sink < 0.5)
                  {

                  //diskmass = diskmass + (P[i].Mass*1.e10/0.7);
                  //nh_avg = nh_avg + P[i].nh*(P[i].Mass/1.03395e-12);
                  //temp_avg = temp_avg + P[i].Temp*(P[i].Mass/1.03395e-12);
                  //num_tot = num_tot + (P[i].Mass/1.03395e-12);

                  diskmass = diskmass + (P[i].Mass*1.e10/0.7);
                  //nh_avg = nh_avg + P[i].nh;
                  nh_avg = nh_avg +(1- 2.*P[i].H2I);

                  if(P[i].sink < 0.5)
                   temp_avg = temp_avg + P[i].Temp;
                  
                  //if(P[i].Temp > 6000)
                  //  printf("ID = %d nh = %lg, temp = %lg, elec %lg, H2 = %lg sink = %lg\n", Id[i], P[i].nh, P[i].Temp, P[i].HII, P[i].H2I, P[i].sink);

                  vrad_avg = vrad_avg + fabs(vrad);
                  vrot_avg = vrot_avg + vrot;
                  omega_avg = omega_avg + omega;
                  num_tot = num_tot + 1.0;

                  if(P[i].sink > 0.5)
                   sinknum++;

                    ncount++;
                    //}
                  }
                }
            //fclose(outfile2);  
            printf("temp = %lg, num_tot = %lg, temp_avg = %lg\n", temp_avg, num_tot, temp_avg/num_tot);

             //outfile=fopen("disk_tot_h2_ng9_nr6e_alt", "a");
             //outfile=fopen("disk_nosink_h2_ng9_nr6e_alt", "a");
             //outfile=fopen("disk_hot_ng9_nr6e_alt", "a");
             //outfile=fopen("disk_test", "a");
             outfile=fopen(output_fname, "a");
             fprintf(outfile, "%15.11g %15.11g %15.11g %15.11g %15.11g %15.11g %15.11g %d\n", Time, diskmass, nh_avg/num_tot, temp_avg/num_tot, vrad_avg/num_tot, vrot_avg/num_tot, omega_avg/num_tot, sinknum);
             fclose(outfile);

             outfile=fopen(output_fname2, "a");
             fprintf(outfile, "%15.11g %15.11g \n", Time, fshield);
             fclose(outfile);

  free(P);
}

  do_what_you_want();
}
コード例 #12
0
ファイル: cut_subfind.c プロジェクト: lgo33/GadTools
int main(int argc, char **argv)
{
	int  i, j, snapshot_number;	
	
	/* Read input and output files */
	i=1;
	if (argc==1) usage();
	while (i<argc)
	  {
      
	    if (!strcmp(argv[i],"-f"))
	      {
		i++;
		strcpy(filename,argv[i]);
		i++;
	      }
	    else if (*argv[i]!='-')
	      {
		strcpy(filename,argv[i]);
		i++;
	      }
	    else if (!strcmp(argv[i],"-i"))
	      {
		i++;
		strcpy(filename,argv[i]);
		i++;
	      }
	    else if (!strcmp(argv[i],"-use"))
	      {
		i++;
		use_cm=atoi(argv[i]);
		i++;
	      }
	    else if (!strcmp(argv[i],"-ind"))
	      {
		i++;
		use_ind = 1;
	      }
	    else if (!strcmp(argv[i],"-s"))
	      {		
		i++;
		StarMassThreshold = atof(argv[i]);
		i++;
	      }
	    else if (!strcmp(argv[i],"-sfid"))
	      {		
		i++;
		sfid = atoi(argv[i]);
		i++;
	      }
	    else if (!strcmp(argv[i],"-m"))
	      {		
		i++;
		TotalMassThreshold = atof(argv[i]);
		i++;
	      }
	    else usage();
	  }
	char snap_number_dum[4];
	sprintf(snap_number_dum, "%.*s", 3, &filename[ strlen(filename)-3]);
	snapshot_number = atoi( snap_number_dum );
	printf("num %d\n", snapshot_number);

	load_groups(snapshot_number);
	
	load_group_ids(snapshot_number);

	load_snapshot(filename, snapshot_number);
	
	write_ascii(snapshot_number);
	
	return 0;
}
コード例 #13
0
int main(int argc, char** argv) {

  char *infile;
  infile=argv[1];
  char *outfile;
  outfile=argv[2];

  float clumpx, clumpy, clumpz;
  sscanf (argv[3],"%f",&clumpx);
  sscanf (argv[4],"%f",&clumpy);
  sscanf (argv[5],"%f",&clumpz);
    
  if(argc!=6) {
    printf("Usage: ./cutout <infile> <outfile> <x coordinate of clump [Mpc]> <y coordinate> <z coordinate>\n");
    return 0;
  }

  printf("Box centered around x: %g y: %g z: %g [Mpc] \n", clumpx, clumpy, clumpz);

  /* load snapshot file */
  io_header header;
  particle_data * P;
  int nTot;
  nTot = load_snapshot(infile, &header, &P);

 
  /* output information about the simulation */
  printf(">> Output from Header \n");
  printf("Boxsize of Simulation: %g\n", header.BoxSize);
  printf("Number of gas particles: %i\n", header.npart[0]);
  printf("Number of high-res dm particles: %i\n", header.npart[1]);
  printf("Number of low-res dm particles: %i\n", header.npart[5]);
  printf("Number of star particles: %i\n", header.npart[4]);

  /*cutout region around the center */
  float extent=20000;
  clumpx=clumpx*1000; 		// Mpc -> kpc 
  clumpy=clumpy*1000; 		// Mpc -> kpc 
  clumpz=clumpz*1000; 		// Mpc -> kpc 

 
  /* check if the cutout region does not extend over boundaries */ 
  if(header.BoxSize-extent/2.<clumpx || extent/2.>clumpx) {
    printf("Out of bound in x-dimension - chose a more centered clump \n" );
    printf(">> ABORTING \n" );
    return 0;  
  }
  if(header.BoxSize-extent/2.<clumpy || extent/2.>clumpy) {
    printf("Out of bound in y-dimension - chose a more centered clump \n" );
    printf(">> ABORTING \n" );
    return 0;  
  }
  if(header.BoxSize-extent/2.<clumpz || extent/2.>clumpz) {
    printf("Out of bound in z-dimension - chose a more centered clump \n" );
    printf(">> ABORTING \n" );
    return 0;  
  } 

    
  int i;
  /* loop over all particles */
  int counter = 0;
  float center = header.BoxSize/2;
  for (i=0;i<nTot;i++) {
    /* test if particle is within our desired volume */
    if(P[i].Pos[0]<clumpx+extent/2 && P[i].Pos[0]>clumpx-extent/2 &&
       P[i].Pos[1]<clumpy+extent/2 && P[i].Pos[1]>clumpy-extent/2 &&
       P[i].Pos[2]<clumpz+extent/2 && P[i].Pos[2]>clumpz-extent/2) {
      /* shift coordinates */
      P[i].Pos[0]-= clumpx-extent/2;
      P[i].Pos[1]-= clumpy-extent/2;
      P[i].Pos[2]-= clumpz-extent/2;
      P[counter] = P[i];
      
      counter++;
    }

  }
  int counterType [6] = {0,0,0,0,0,0};
  /* get the numbers of the particle types */
  for (i=0;i<counter;i++) {
    if(P[i].Type==0) {
      counterType[0]+=1;
    }
    if(P[i].Type==1) {
      counterType[1]+=1;
    }
    if(P[i].Type==2) {
      counterType[2]+=1;
    }
    if(P[i].Type==3) {
      counterType[3]+=1;
    }
    if(P[i].Type==4) {
      counterType[4]+=1;
    }
    if(P[i].Type==5) {
      counterType[5]+=1;
    }
  }

  header.npart[0]=counterType[0];
  header.npartTotal[0]=counterType[0];
  header.npart[1]=counterType[1];
  header.npartTotal[1]=counterType[1];
  header.npart[4]=counterType[4];
  header.npartTotal[4]=counterType[4];
  header.npart[5]=counterType[5];
  header.npartTotal[5]=counterType[5];
  header.BoxSize = extent;

  /* output information about the simulation */
  printf(">> Output Cutout Box\n");
  printf("Boxsize: %g\n", header.BoxSize);
  printf("Number of gas particles: %i\n", header.npart[0]);
  printf("Number of high-res dm particles: %i\n", header.npart[1]);
  printf("Number of low-res dm particles: %i\n", header.npart[5]);
  printf("Number of star particles: %i\n", header.npart[4]);
  printf("Box centered around x: %g y: %g z: %g \n", clumpx, clumpy, clumpz);


  /* write reduced snapshot file */
  write_snapshot(outfile, &header, P);

  return 0;
}
コード例 #14
0
ファイル: radprof.c プロジェクト: AthenaStacy/gadget_analysis
/* Here we load a snapshot file. It can be distributed
 * onto several files (for files>1).
 * The particles are brought back into the order
 * implied by their ID's.
 * A unit conversion routine is called to do unit
 * conversion, and to evaluate the gas temperature.
 */
int main(int argc, char **argv)
{
  char path[200], input_fname[200], output_fname[200], output_fname2[200], basename[200], basenameout[200];
  int  i, k=0, j, n, type, snapshot_number, files, Ngas, random, ncount, ncounthalo1, arrnum=200;
  double x,y,z,x1,y1,z1, delr;
  double nh, nhmax, mass, mmax, dis, dis_sim, disAU, xmax, ymax, zmax, sl, masstot, temp, tmax, h2, h2max, gam, gammin;
  int IDmax;
  double rho_b, rho_DM[arrnum], rho_vir, r_vir, v_vir;
  double kB, G;
  double bind, diskmass, massin=0.0, massout=0.0;
  double vrad, vrot, disAUxy, disAUz, disAUxyz, vx_com, vy_com, vz_com, vx1, vy1, vz1, vx2, vy2, vz2, vx3, vy3, vz3, vx4, vy4, vz4;
  double sinkposx1, sinkposy1, sinkposz1, sinkposx2, sinkposy2, sinkposz2; 
  double sinkposx3, sinkposy3, sinkposz3, sinkposx4, sinkposy4, sinkposz4;
  double num, amom, amom_arr[arrnum], amomtot, amomx_tot, amomy_tot; 
  double amomz_tot, amomx, amomy, amomz, amomx1, amomx2, amomy1, amomy2, amomz1, amomz2;
  double xfac, yfac, zfac, kfloat, nh_avg, num_tot, omega, omega0, nthresh;
  double xtimesm, ytimesm, ztimesm, vxtimesm, vytimesm, vztimesm;
  double xCOM, yCOM, zCOM, vxCOM, vyCOM, vzCOM, jzcent;
  double temp_arr[arrnum], mbe_arr[arrnum], omega_arr[arrnum];
  double m_enc_arr[arrnum], d_arr[arrnum], mass_enc, n_arr[arrnum], n_arr2[arrnum], surf_dens_arr[arrnum];
  double rmin, rmax, nmin, nmax, numdens_arr[arrnum]; 
  double vradx, vrady, vradz, vrotx, vroty, vrotz, vrad_arr[arrnum], vrot_arr[arrnum], dens_arr[arrnum], c_s_arr[arrnum]; 
  double vradx_arr[arrnum], vrady_arr[arrnum], vradz_arr[arrnum], vrotx_arr[arrnum], vroty_arr[arrnum], vrotz_arr[arrnum];
  double velx, vely, velz, velx_arr[arrnum], vely_arr[arrnum], velz_arr[arrnum];
  double mdm_enc_arr[arrnum], turb_arr[arrnum], disx, disy, disz;
  double KE, KE_tot, PE, PE_tot, vel, spin_param, ncount_doub;
  int ID_sink1, ID_sink2, ID_sink3, ID_sink4, sinknumk;
  FILE *outfile, *outfile2;

  sprintf(path, "/work/00863/minerva/bin_zoom");
  //sprintf(basename, "ifront_hiacc");

  //sprintf(path, "/nobackupp1/astacy/binHR");
  //sprintf(basename, "bin_HR1");
  //sprintf(basename, "bin_HR7");
  //sprintf(basename, "bin_HR10");

  //sprintf(path, "/nobackupp1/astacy/bin_zoom");
  //sprintf(basename, "bin_zoom1");
  //sprintf(basename, "bin_zoom2");
  //sprintf(basename, "bin_zoom3");
  //sprintf(basename, "bin_zoom4");
  //sprintf(basename, "bin_zoom5");
  //sprintf(basename, "bin_zoom6");
  //sprintf(basename, "bin_zoom7");
  //sprintf(basename, "bin_zoom9");
  //sprintf(basename, "bin_zoom10");


  //for(j=453;j<=453;j++)
  //for(j=6;j<=6;j++)	
  //for(j=9;j<=9;j++)
  //for(j=1;j<=1;j++)
  //for(j=90;j<=90;j++)
  //for(j=77;j<=77;j++)
  //for(j=86;j<=86;j++)
  //for(j=127;j<=127;j++)
  //for(j=112;j<=112;j++)
  //for(j=139;j<=139;j++)
  //for(j=91;j<=91;j++)
  //for(j=113;j<=113;j++)  
  //for(j=101;j<=101;j++)

/*
  sprintf(path, "/scratch/00863/minerva");
  sprintf(basename, "bin_zoom9_new_ref3");  
  for(j=6800;j<=6800;j=j+20)
*/


  sprintf(path, "/scratch/00863/minerva");
  sprintf(basename, "bin_zoom10_new_ref3");  
  for(j=5600;j<=5600;j=j+20)

  //for(j=40;j<=80;j=j+20)
  {
  
  snapshot_number= j;                   /* number of snapshot */
  files=1;                               /* number of files per snapshot */

  sprintf(input_fname, "%s/%s_%03d", path, basename, snapshot_number);
  //sprintf(input_fname, "%s/%s_%04d", path, basename, snapshot_number);
  Ngas = load_snapshot(input_fname, files);

  sprintf(output_fname, "%s_mini_%03d.dat",basename, snapshot_number);
  if(j > 999) sprintf(output_fname, "%s_mini_%04d.dat",basename, snapshot_number);

          /*    reordering();*/ /* call this routine only if your ID's are set properly */

  rho_b = 2.94e-30; //background density of the universe

  unit_conversion();

  nh_avg=ncount_doub=0;
  num_tot=0;
  h2max=nhmax=mmax=kfloat=0.0;
  xtimesm = ytimesm = ztimesm = 0.0;
  vxtimesm = vytimesm = vztimesm = 0.0;
  vxCOM=vyCOM=vzCOM=xCOM=yCOM=zCOM=0;
  amomx_tot = amomy_tot = amomz_tot = 0;
  amomtot = omega0 = masstot = 0.0;
  
  nthresh = 1.e4;	  	
	
       for(i = 0; i < Ngas; i++)
        {
       if(P[i].nh > nhmax /*&& P[i].sink < 0.5*/)
   	   {
           nhmax = P[i].nh;
           IDmax = P[i].Id;
           xmax = P[i].Pos[0];
           ymax = P[i].Pos[1];
           zmax = P[i].Pos[2];
           mmax = P[i].Mass;
           }
         }
	printf("xmax = %lg ymax = %lg zmax = %lg mmax = %lg nhmax = %lg\n", xmax, ymax, zmax, mmax, nhmax);

        for(n=0;n<=Ngas;n++) 
         {
           nh = P[n].nh;
           dis = pow(((P[n].Pos[0]-xmax)*(P[n].Pos[0]-xmax) + (P[n].Pos[1]-ymax)*(P[n].Pos[1]-ymax) + (P[n].Pos[2]-zmax)*(P[n].Pos[2]-zmax)), 0.5);
           dis=dis*1.e3*Time/(0.7);
           disx = fabs((P[n].Pos[0]-xmax))*1.e3*Time/(0.7);
           disy = fabs((P[n].Pos[1]-ymax))*1.e3*Time/(0.7);
           disz = fabs((P[n].Pos[2]-zmax))*1.e3*Time/(0.7);
           disAU=dis*206264.806;
           if(disx < width && disy < width && disz < width)
            {
            vxCOM = vxCOM + P[n].Vel[0]*P[n].Mass;
            vyCOM = vyCOM + P[n].Vel[1]*P[n].Mass;
            vzCOM = vzCOM + P[n].Vel[2]*P[n].Mass;
            xCOM = xCOM + P[n].Pos[0]*P[n].Mass;
            yCOM = yCOM + P[n].Pos[1]*P[n].Mass;
            zCOM = zCOM + P[n].Pos[2]*P[n].Mass;
            ncount_doub = ncount_doub + P[n].Mass;
            }
        }

         vx1 = vxCOM/ncount_doub;
         vy1 = vyCOM/ncount_doub;
         vz1 = vzCOM/ncount_doub;
         //vx = vy = vz = 0;

	sinkposx1 = xmax;
	sinkposy1 = ymax;
	sinkposz1 = zmax;

        printf("vx1 = %lg, vy1 = %lg, vz1 = %lg, sinkposx1 = %lg, sinkposy1 = %lg, sinkposz1 = %lg\n", vx1, vy1, vz1, sinkposx1, sinkposy1, sinkposz1);

	diskmass=0.0;
	ncount=0;  
	ncount_doub=0.;
	  

	rmin = 100.;
        rmax = 3e8;
        nmin = 1.e-2;
        nmax = 1.e12;

        for(n=0; n<arrnum; n++)
          {
          m_enc_arr[n] = amom_arr[n] = n_arr[n] = n_arr2[n]  = surf_dens_arr[n] = c_s_arr[n] = 0.0;
          temp_arr[n] = mbe_arr[n] = omega_arr[n] = 0.0; 
          vrot_arr[n] = vrotx_arr[n] = vroty_arr[n] = vrotz_arr[n] = 0;
          vrad_arr[n] = vradx_arr[n] = vrady_arr[n] = vradz_arr[n] = 0;
          rho_DM[n] = 0.0;
          //d_arr[n] = (double(n)/199.0)*5.e8;
          //d_arr[n] = pow(5.e8,double(n)/double(arrnum));
          d_arr[n] = rmin * pow(rmax/rmin, double(n)/double(arrnum));
          numdens_arr[n] = nmin * pow(nmax/nmin, double(n)/double(arrnum));
          //printf("d_arr[%d] = %lg\n", n, d_arr[n]);
          }
 
         //for(i = Ngas; i < NumPart; i++)
         for(i = 0; i < NumPart; i++)
               {
	       dis = pow(((P[i].Pos[0]-sinkposx1)*(P[i].Pos[0]-sinkposx1) + (P[i].Pos[1]-sinkposy1)*(P[i].Pos[1]-sinkposy1) + (P[i].Pos[2]-sinkposz1)*(P[i].Pos[2]-sinkposz1)), 0.5);
	       dis=dis*1.e3*Time/(0.7);                   //dis is in pc
	       disAU = dis*206264.8060;
	       if(disAU < 5.e8)
                    {
                    for(n=0; n<arrnum; n++)
                      {
                      if(disAU < d_arr[n] && P[i].Type == 0)
                        m_enc_arr[n] = m_enc_arr[n] + P[i].Mass*1.e10/0.7;
                      if(disAU < d_arr[n] && P[i].Type == 1)
                        mdm_enc_arr[n] = mdm_enc_arr[n] + P[i].Mass*1.e10/0.7;
                      } 
                     }
                  }

          for(n=0; n<arrnum; n++)
               {
               rho_DM[n] = mdm_enc_arr[n]*1.98892e33/((4.0/3.0)*3.14159*pow(d_arr[n]*1.5e13, 3.0));  //DM density in cgs
               printf("mdm_enc_arr[%d] = %lg\n", n, mdm_enc_arr[n]);
               //printf("rho_DM[%d] = %lg\n", n, rho_DM[n]/(rho_b*pow(Time, -3.0)));
               if(rho_DM[n] > 200.0*rho_b*pow(Time, -3.0))
                 {
                 rho_vir = rho_DM[n];
                 r_vir = d_arr[n];
                 }
               }
	  
	
             //rotate(sinkposx1,sinkposy1,sinkposz1, vx1, vy1, vz1);
 
         //for(i = Ngas; i < NumPart; i++)
         for(i = 0; i < Ngas; i++)
                {

                 P[i].Vel[0] = P[i].Vel[0] - vx1;
                 P[i].Vel[1] = P[i].Vel[1] - vy1;
                 P[i].Vel[2] = P[i].Vel[2] - vz1;
          
                 amomx = (P[i].Pos[1]-sinkposy1)*P[i].Vel[2]  - (P[i].Pos[2]-sinkposz1)*P[i].Vel[1];
                 amomy = (P[i].Pos[2]-sinkposz1)*P[i].Vel[0] - (P[i].Pos[0]-sinkposx1)*P[i].Vel[2];
                 amomz = (P[i].Pos[0]-sinkposx1)*P[i].Vel[1]  -  (P[i].Pos[1]-sinkposy1)*P[i].Vel[0];

                 amomx = (P[i].Mass*1.e10*1.98892e33/.7)*amomx*pow(Time, 0.5)*1.e5*3.086e18*1.e3*Time/(0.7);  //convert to cgs units
                 amomy = (P[i].Mass*1.e10*1.98892e33/.7)*amomy*pow(Time, 0.5)*1.e5*3.086e18*1.e3*Time/(0.7);
                 amomz = (P[i].Mass*1.e10*1.98892e33/.7)*amomz*pow(Time, 0.5)*1.e5*3.086e18*1.e3*Time/(0.7);

                 amom = pow(amomx*amomx + amomy*amomy + amomz*amomz, 0.5);  //ang. mom. of particle in cgs

                 vel = pow(P[i].Vel[0]*P[i].Vel[0] + P[i].Vel[1]*P[i].Vel[1] + P[i].Vel[2]*P[i].Vel[2], 0.5);
                 vel = vel*pow(Time, 0.5)*1.e5;  //convert vel to cgs 

                 KE = 0.5*(P[i].Mass*1.e10*1.98892e33/.7)*pow(vel,2.0);   //kinetic energy in cgs

                 velx = P[i].Vel[0]*pow(Time, 0.5);
                 vely = P[i].Vel[1]*pow(Time, 0.5);
                 velz = P[i].Vel[2]*pow(Time, 0.5);

                 dis_sim = pow(((P[i].Pos[0]-sinkposx1)*(P[i].Pos[0]-sinkposx1) + (P[i].Pos[1]-sinkposy1)*(P[i].Pos[1]-sinkposy1) + (P[i].Pos[2]-sinkposz1)*(P[i].Pos[2]-sinkposz1)), 0.5);
                 dis = pow(((P[i].Pos[0]-sinkposx1)*(P[i].Pos[0]-sinkposx1) + (P[i].Pos[1]-sinkposy1)*(P[i].Pos[1]-sinkposy1) + (P[i].Pos[2]-sinkposz1)*(P[i].Pos[2]-sinkposz1)), 0.5); 
                 dis=dis*1.e3*Time/(0.7);                   //dis is in pc
                 disAU = dis*206264.8060;
                 dis=dis*3.086e18;   //dis in now in cm                

                 vrot  = amom/(P[i].Mass*1.e10*1.98892e33/.7)/dis/1e5;
                 vrotx = amomx/(P[i].Mass*1.e10*1.98892e33/.7)/dis/1e5;              
                 vroty = amomy/(P[i].Mass*1.e10*1.98892e33/.7)/dis/1e5;
                 vrotz = amomz/(P[i].Mass*1.e10*1.98892e33/.7)/dis/1e5; //vrot in km/s 
                 omega = (P[i].Mass/1.e-10/.7)*vrot/(disAU*1.5e8); 

             if(P[i].nh > nthresh && disAU > 0)
                   {
                   masstot = masstot + P[i].Mass/1.e-10/.7;
                   omega0 = omega0 + (P[i].Mass/1.e-10/.7)*vrot/(disAU*1.5e8);  //divide vrot by distance in km
                   }

                 disAUxyz = pow((P[i].Pos_new[0])*(P[i].Pos_new[0]) + (P[i].Pos_new[1])*(P[i].Pos_new[1]) + (P[i].Pos_new[2])*(P[i].Pos_new[2]), 0.5);
                 disAUxyz = disAUxyz*1.e3*Time/(0.7)*206264.8060;

                 disAUxy = pow(((P[i].Pos_new[0])*(P[i].Pos_new[0]) + (P[i].Pos_new[1])*(P[i].Pos_new[1])), 0.5);
                 disAUxy = disAUxy*1.e3*Time/(0.7)*206264.8060;
 
                 disAUz = fabs(P[i].Pos_new[2]*1.e3*Time/(0.7)*206264.8060);  

                 vrad =  (P[i].Vel[0]*(P[i].Pos[0]-sinkposx1) + P[i].Vel[1]*(P[i].Pos[1]-sinkposy1) + P[i].Vel[2]*(P[i].Pos[2]-sinkposz1))/dis_sim;
                 vrad = vrad*pow(Time, 0.5);
                 vradx = (P[i].Vel[0]*(P[i].Pos[0]-sinkposx1))/dis_sim*pow(Time, 0.5);
                 vrady = (P[i].Vel[1]*(P[i].Pos[1]-sinkposy1))/dis_sim*pow(Time, 0.5);
                 vradz = (P[i].Vel[2]*(P[i].Pos[2]-sinkposz1))/dis_sim*pow(Time, 0.5); 

                 if(disAU < r_vir /*&& KE + PE < 0.0*/)
                   {
                   KE_tot = KE_tot + KE;
                   PE_tot = PE_tot + PE;
                   amomtot = amomtot + amom;
                   amomx_tot = amomx_tot + amomx;          
                   amomy_tot = amomy_tot + amomy;
                   amomz_tot = amomz_tot + amomz;
                   num_tot = num_tot + P[i].Mass;
		   ncount++;  
                   }

                 if(P[i].nh > 1.e-2)
                   for(n=0; n<arrnum; n++)
                    {
                    if(disAU > d_arr[n] && disAU < d_arr[n+1] && P[i].sink < 0.5)
                      {
                      amom_arr[n] = amom_arr[n] + amom/(P[i].Mass*1.e10*1.98892e33/.7);
                      dens_arr[n] = dens_arr[n] + P[i].nh;
                      c_s_arr[n] = c_s_arr[n] + pow(1.38e-16*P[i].Temp/1.e-24,0.5)/1.e5;
                      temp_arr[n] = temp_arr[n] + P[i].Temp;
                      mbe_arr[n] = mbe_arr[n] + 1050.*pow(P[i].Temp/200.,1.5)*pow(P[i].nh/1.e4,-0.5);

                      velx_arr[k] = velx_arr[k] + velx;
                      vely_arr[k] = vely_arr[k] + vely;
                      velz_arr[k] = velz_arr[k] + velz;
                      vrad_arr[n] = vrad_arr[n] + vrad;
                      //vrot_arr[n] = vrot_arr[n] + vrot;
                      vradx_arr[n] = vradx_arr[n] + vradx;
                      vrady_arr[n] = vrady_arr[n] + vrady;
                      vradz_arr[n] = vradz_arr[n] + vradz;
                      vrotx_arr[n] = vrotx_arr[n] + vrotx;
                      vroty_arr[n] = vroty_arr[n] + vroty;
                      vrotz_arr[n] = vrotz_arr[n] + vrotz;
                      n_arr[n]=n_arr[n] + 1.0;
                      }
                     if(disAU < d_arr[n+1] && disAU > 0)
                       omega_arr[n] = omega_arr[n] + omega;
                     }

                 if(P[i].nh > 1.e-2)
                   for(n=0; n<arrnum; n++) 
                    {   
                    if(disAUxy > d_arr[n] && disAUxy < d_arr[n+1] && disAUz < 10.  && P[i].sink < 0.5)
                    //if(disAUxyz > d_arr[n] && disAUxyz < d_arr[n+1] && P[i].sink < 0.5)
                     {
                     surf_dens_arr[n] = surf_dens_arr[n] + P[i].Mass*1.e10*1.98892e33/.7;
                     n_arr2[n]=n_arr2[n] + 1.0;                     
                     }
                    }
                }

             outfile=fopen(output_fname, "a");
             for(n=0; n<arrnum; n++)
                   {
                   printf("n_arr2 = %lg , c_s = %lg, vrad = %lg, surf_dens = %lg omega = %lg\n", n_arr2[n], c_s_arr[n], vrad_arr[n], surf_dens_arr[n], omega_arr[n]);
                   dens_arr[n] = dens_arr[n]/n_arr[n];

                   velx_arr[n] = velx_arr[n]/n_arr[n];
                   vely_arr[n] = vely_arr[n]/n_arr[n];
                   velz_arr[n] = velz_arr[n]/n_arr[n];
                   vradx_arr[n] = vradx_arr[n]/n_arr[n];
                   vrady_arr[n] = vrady_arr[n]/n_arr[n];
                   vradz_arr[n] = vradz_arr[n]/n_arr[n];
                   vrotx_arr[n] = vrotx_arr[n]/n_arr[n];
                   vroty_arr[n] = vroty_arr[n]/n_arr[n];
                   vrotz_arr[n] = vrotz_arr[n]/n_arr[n];
                   //vrad_arr[n] = pow(vradx_arr[n]*vradx_arr[n] + vrady_arr[n]*vrady_arr[n] + vradz_arr[n]*vradz_arr[n], 0.5)/n_arr[n];
                   vrad_arr[n] = vrad_arr[n]/n_arr[n];
                   vrot_arr[n] = pow(vrotx_arr[n]*vrotx_arr[n] + vroty_arr[n]*vroty_arr[n] + vrotz_arr[n]*vrotz_arr[n], 0.5)/n_arr[n];
                   c_s_arr[n] = c_s_arr[n]/n_arr[n];
                   temp_arr[n] = temp_arr[n]/n_arr[n];
                   mbe_arr[n] = mbe_arr[n]/n_arr[n];
                   surf_dens_arr[n] = surf_dens_arr[n]/3.14159/(pow(1.4958e13*d_arr[n+1],2) - pow(1.4958e13*d_arr[n],2));

	           turb_arr[n] = pow(velx_arr[n] - vradx_arr[n] - vrotx_arr[n],2) + pow(vely_arr[n] - vrady_arr[n] - vroty_arr[n],2) + pow(velz_arr[n] - vradz_arr[n] - vrotz_arr[n],2);
      		   turb_arr[n] = pow(turb_arr[n], 0.5);

      		   vrot_arr[n] = pow(vrotx_arr[n]*vrotx_arr[n] + vroty_arr[n]*vroty_arr[n] + vrotz_arr[n]*vrotz_arr[n], 0.5);
      		   if(n > 0)
        		amom_arr[n] = (m_enc_arr[k] - m_enc_arr[k-1])*vrot_arr[n]*d_arr[n]*1.5e13*1.e5*2.e33;
      		   if(n == 0)
        		amom_arr[n] = m_enc_arr[0]*vrot_arr[0]*d_arr[0]*1.5e13*1.e5*2.e33;


                   fprintf(outfile, "%15.11g %15.11g %15.11g %15.11g %15.11g %15.11g %15.11g %15.11g %15.11g %15.11g %15.11g %15.11g %15.11g\n", d_arr[n], m_enc_arr[n], mdm_enc_arr[n], dens_arr[n], surf_dens_arr[n], c_s_arr[n], temp_arr[n], mbe_arr[n], omega_arr[n]/m_enc_arr[n], vrad_arr[n], vrot_arr[n], turb_arr[n], amom_arr[n]);
                   }
             fclose(outfile);
 
             free(P);
  }

}
コード例 #15
0
ファイル: barbershop.c プロジェクト: BuloZB/barbershop
int main(int argc, char **argv)
{
	int port = SERVER_PORT;
	timeout = 60;
	static int daemon_mode = 0;

	int c;
	while (1) {
		static struct option long_options[] = {
			{"daemon",  no_argument,       &daemon_mode, 1},
			{"file",      required_argument, 0, 'f'},
			{"port",    required_argument, 0, 'p'},
			{"sync",    required_argument, 0, 's'},
			{0, 0, 0, 0}
		};
		int option_index = 0;
		c = getopt_long(argc, argv, "f:p:s:", long_options, &option_index);
		if (c == -1) { break; }
		switch (c) {
			case 0:
				if (long_options[option_index].flag != 0) { break; }
				printf ("option %s", long_options[option_index].name);
				if (optarg) { printf(" with arg %s", optarg); }
				printf("\n");
				break;
			case 'f':
				sync_file = optarg;
				break;
			case 'p':
				port = atoi(optarg);
				break;
			case 's':
				timeout = atoi(optarg);
				break;
			case '?':
				/* getopt_long already printed an error message. */
				break;
			default:
				abort();
		}
	}
	if (daemon_mode == 1) {
		daemonize();
	}
	if (sync_file == NULL) {
		sync_file = "barbershop.snapshot";
	}

	// side snapshot file to hot load a snapshot by sending SIGHUP
	int n = strlen(sync_file);
	load_file = malloc(sizeof(char) * (n + 6));
	sprintf(load_file, "%s.load", sync_file);

	initializePriorityQueue();

	time(&app_stats.started_at);
	app_stats.version = "00.02.01";
	app_stats.updates = 0;
	app_stats.items = 0;
	app_stats.pools = 0;
	
	load_snapshot(sync_file);
	signal(SIGCHLD, SIG_IGN);
	signal(SIGPIPE, SIG_IGN);
	signal(SIGTSTP, SIG_IGN);
	signal(SIGTTOU, SIG_IGN);
	signal(SIGTTIN, SIG_IGN);
	signal(SIGHUP, signal_handler); /* catch hangup signal */
	signal(SIGTERM, signal_handler); /* catch kill signal */
	
	pthread_t garbage_collector;
	pthread_create(&garbage_collector, NULL, (void *) gc_thread, NULL);

	int listen_fd;
	struct sockaddr_in listen_addr;
	int reuseaddr_on = 1;
	struct event ev_accept;
	event_init();
	listen_fd = socket(AF_INET, SOCK_STREAM, 0);
	if (listen_fd < 0) { err(1, "listen failed"); }
	if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_on, sizeof(reuseaddr_on)) == -1) { err(1, "setsockopt failed"); }
	memset(&listen_addr, 0, sizeof(listen_addr));
	listen_addr.sin_family = AF_INET;
	listen_addr.sin_addr.s_addr = INADDR_ANY;
	listen_addr.sin_port = htons(port);
	if (bind(listen_fd, (struct sockaddr *)&listen_addr, sizeof(listen_addr)) < 0) { err(1, "bind failed"); }
	if (listen(listen_fd, 5) < 0) { err(1, "listen failed"); }
	if (setnonblock(listen_fd) < 0) { err(1, "failed to set server socket to non-blocking"); }
	event_set(&ev_accept, listen_fd, EV_READ|EV_PERSIST, on_accept, NULL);
	event_add(&ev_accept, NULL);
	event_dispatch();

	return 0;
}
コード例 #16
0
ファイル: barbershop.c プロジェクト: BuloZB/barbershop
void snap_thread()
{
	load_snapshot(load_file);
	respond_empty = 0;
	pthread_exit(0);
}