int main(int argc, char **argv)
{
/**************/
/* Read Input */
/**************/
check(argc == 2, "%s requires input file.", argv[1]);
struct gadget_header_t *header = read_gadget_header(argv[1]);
struct gadget_particle_t *ps = read_gadget_particles(argv[1]);
uint32_t len = header->npart[1];
/***********************/
/* Calculate Distances */
/***********************/
struct gadget_particle_t *sorted_ps = malloc(sizeof(*sorted_ps) * len);
check_mem(sorted_ps);
memcpy(sorted_ps, ps, len * sizeof(*sorted_ps));
qsort(sorted_ps, len, sizeof(*ps), id_cmp);
int dist_len;
float *dists = neighbor_distances(ps, sorted_ps, len, &dist_len);
float max_dist, min_dist;
float_min_max(dists, dist_len, &min_dist, &max_dist);
for (int i = 0; i < dist_len; i++) {
dists[i] = log10(dists[i]);
}
int bins = 100;
int *counts = calloc(sizeof(*counts), bins);
float *centers = calloc(sizeof(*centers), bins);
float_bin_data(bins, dists, dist_len, counts, centers);
/****************/
/* Print Output */
/****************/
printf("#%25s: %g\n", "Redshift", header->redshift);
printf("#%25s: %d / %d (%.2g percent)\n", "Neighobors in box",
dist_len, len * 3, 100 * ((float) dist_len) / (3.0 * len));
printf("#%25s: %g\n", "Maximum distance", max_dist);
printf("#%25s: %g\n", "Minimum distance", min_dist);
printf("# %15s %15s\n", "log10(dist)", "count");
for (int i = 0; i < bins; i++){
printf(" %15g %15d\n", centers[i], counts[i]);
}
free(header);
free(ps);
free(sorted_ps);
return 0;
}
int main(int argc, char **argv)
{
float Hubble=0.1;
int i,dummy,dummy2,n,ns;
long int Ntotal=0;
FILE *fp;
IO_HEADER h;
char snapfile[1024];
if(argc!=2)
{
printf("usage: %s [filename]\n ",argv[0]);
exit(1);
}
strcpy(snapfile,argv[1]);
/*=====reading snapshot========*/
if((fp=fopen(snapfile,"r"))==NULL)
{
fprintf(stderr,"error: file open failed for %s!\n",snapfile);
fflush(stderr);
exit(1);
}
read_gadget_header(fp,&h);
printf("partnum\t\tpartnum_total\t\tpartmass\n");
for(i=0; i<6; i++)
{
printf("%d\t\t%u\t\t%g\n",h.npart[i],h.npartTotal[i],h.mass[i]);
Ntotal+=h.npartTotal[i];
}
printf("---------------------------------------\n");
printf("Ntotal:\t\t%ld\n",Ntotal);
printf("NFiles:\t\t%d\n",h.num_files);
printf("SFR: %d\tFeedback: %d\tCooling: %d\n",h.flag_sfr,h.flag_feedback,h.flag_cooling);
printf("Boxsize:%g\nOmega0:%f\t OmegaL0:%f\t h: %f\t Hz: %f\n",h.BoxSize,h.Omega0,h.OmegaLambda,h.HubbleParam,h.Hz);
printf("Redshift: %3.2f\tscaleFac: %g\n",h.redshift,h.time);
return 0;
}
void print_header(char *file_name)
{
struct gadget_header_t *header = read_gadget_header(file_name);
uint64_t total = ((((uint64_t)header->npart_total[0]) << 32) +
header->npart_total[1]);
printf("%20s: %u/%"PRIu64"\n", "Particles", header->npart[1], total);
printf("%20s: %g\n", "Mass", header->mass[1]);
printf("%20s: %g\n", "Redshift", header->redshift);
printf("%20s: %g\n", "Box Size", header->box_size);
printf("%20s: %d\n", "Snapshot Files", header->num_files);
struct gadget_particle_t *ps = read_gadget_particles(file_name);
for (int i = 0; i < 20; i++) print_particle(ps + i);
free(header);
free(ps);
}
void load_particle_header(HBTInt Nsnap, char *SnapPath)
{
FILE *fp;
char buf[1024];
HBTInt NumPart;
#ifdef SNAPLIST
Nsnap=snaplist[Nsnap];
#endif
sprintf(buf,"%s/snapdir_%03d/%s_%03d.0",SnapPath,(int)Nsnap,SNAPFILE_BASE,(int)Nsnap);
if(1==NFILES)
if(!try_readfile(buf)) sprintf(buf,"%s/%s_%03d",SnapPath,SNAPFILE_BASE,(int)Nsnap); //try the other convention
if(!try_readfile(buf)) sprintf(buf,"%s/%s_%03d.%d",SnapPath,SNAPFILE_BASE,(int)Nsnap,0); //try the other convention
if(!try_readfile(buf)) sprintf(buf,"%s/%d/%s.%d",SnapPath,(int)Nsnap,SNAPFILE_BASE,0);//for BJL's RAMSES output
myfopen(fp,buf,"r");
read_gadget_header(fp,&header);
fclose(fp);
header.Nsnap=Nsnap;
}
/* this routine loads particle data from Gadget's default
* binary file format. (A snapshot may be distributed
* into multiple files). use the bitwise loadflags to
* determine which part of the data to load. the last 3 bits
* of loadflags encodes whether to load vel, pos and id.
*/
void load_particle_data_bypart(HBTInt Nsnap, char *SnapPath, unsigned char loadflags)
{
unsigned char flag_id,flag_pos,flag_vel;
int dummy,dummy2,ByteOrder;
long int pre_len,tail_len;
FILE *fp;
char buf[1024];
HBTInt i,j;
HBTInt Nload=0;
struct
{
IDatInt *PID;
IDatReal (*Pos)[3];
IDatReal (*Vel)[3];
} IDat; //input particle data, temporary.
/*loadflags encodes the flag to load id,pos,vel in its lowest,second lowest and third lowest bit */
flag_id=get_bit(loadflags,0);
flag_pos=get_bit(loadflags,1);
flag_vel=get_bit(loadflags,2);
IDat.PID=NULL;
IDat.Pos=NULL;
IDat.Vel=NULL;
if(flag_id)
IDat.PID=mymalloc(sizeof(IDatInt)*NP_DM);
if(flag_pos)
IDat.Pos=mymalloc(sizeof(IDatReal)*3*NP_DM);
if(flag_vel)
IDat.Vel=mymalloc(sizeof(IDatReal)*3*NP_DM);
Pdat.Nsnap=Nsnap;
#ifdef SNAPLIST
Nsnap=snaplist[Nsnap];
#endif
for(i=0; i<NFILES; i++)
{
sprintf(buf,"%s/snapdir_%03d/%s_%03d.%d",SnapPath,(int)Nsnap,SNAPFILE_BASE,(int)Nsnap,(int)i);
if(1==NFILES)
if(!try_readfile(buf)) sprintf(buf,"%s/%s_%03d",SnapPath,SNAPFILE_BASE,(int)Nsnap); //try the other convention
if(!try_readfile(buf)) sprintf(buf,"%s/%s_%03d.%d",SnapPath,SNAPFILE_BASE,(int)Nsnap,(int)i); //try the other convention
if(!try_readfile(buf)) sprintf(buf,"%s/%d/%s.%d",SnapPath,(int)Nsnap,SNAPFILE_BASE,(int)i);//for BJL's RAMSES output
myfopen(fp,buf,"r");
ByteOrder=read_gadget_header(fp,&header);
header.Nsnap=Nsnap;
pre_len=header.npart[0]*sizeof(IDatReal)*3;
for(j=2,tail_len=0;j<6;j++)tail_len+=header.npart[j];
tail_len*=sizeof(IDatReal)*3;
SKIP;
fseek(fp,pre_len,SEEK_CUR);//load only DM data;
if(flag_pos)
myfread(IDat.Pos+Nload,sizeof(IDatReal)*3,header.npart[1],fp);
else
fseek(fp,sizeof(IDatReal)*3*header.npart[1],SEEK_CUR);
fseek(fp,tail_len,SEEK_CUR);
SKIP2;
CHECK;
SKIP;
fseek(fp,pre_len,SEEK_CUR);//load only DM data;
if(flag_vel)
myfread(IDat.Vel+Nload,sizeof(IDatReal)*3,header.npart[1],fp);
else
fseek(fp,sizeof(IDatReal)*3*header.npart[1],SEEK_CUR);
fseek(fp,tail_len,SEEK_CUR);
SKIP2;
CHECK;
#ifndef NO_ID_RECORD //for Huiyuan's data.
pre_len=header.npart[0]*sizeof(IDatInt);
for(j=2,tail_len=0;j<6;j++)tail_len+=header.npart[j];
tail_len*=sizeof(IDatInt);
SKIP;
fseek(fp,pre_len,SEEK_CUR);//load only DM data;
if(flag_id)
myfread(IDat.PID+Nload,sizeof(IDatInt),header.npart[1],fp);
else
fseek(fp,sizeof(IDatInt)*header.npart[1],SEEK_CUR);
fseek(fp,tail_len,SEEK_CUR);
SKIP2;
CHECK;
#endif
if(feof(fp))
{
fprintf(logfile,"error:End-of-File in %s\n",buf);
fflush(logfile);exit(1);
}
Nload+=header.npart[1];
fclose(fp);
}
if(NP_DM!=Nload)
{
fprintf(logfile,"error: Number of loaded DM particles mismatch: %lld,%lld\n",(long long)NP_DM,(long long)Nload);
fflush(logfile);
exit(1);
}
if(flag_id)
{
//now transfer to HBT's internal data
#ifdef HBTPID_RANKSTYLE
struct io_ID2Ind *table;
table=mymalloc(sizeof(struct io_ID2Ind)*NP_DM);
for(i=0;i<NP_DM;i++)
{
table[i].PID=IDat.PID[i];
table[i].PInd=i;
}
qsort(table,NP_DM,sizeof(struct io_ID2Ind),comp_PIDArr);
Pdat.PID=mymalloc(sizeof(HBTInt)*NP_DM);
for(i=0;i<NP_DM;i++)
Pdat.PID[table[i].PInd]=i; //now PID has been turned into particle ranks
sprintf(buf,"%s/DM_PIDs_Sorted.dat",SUBCAT_DIR);
if(!try_readfile(buf))//create the file if it does not exist
{
IDatInt np;
myfopen(fp,buf,"w");
np=NP_DM;
fwrite(&np,sizeof(IDatInt),1,fp);
for(i=0;i<NP_DM;i++)
fwrite(&(table[i].PID),sizeof(IDatInt),1,fp);
fwrite(&np,sizeof(IDatInt),1,fp);
fclose(fp);
}
myfree(table);
myfree(IDat.PID);
#else
#ifdef SAME_INTTYPE
Pdat.PID=IDat.PID;
#else
Pdat.PID=mymalloc(sizeof(HBTInt)*NP_DM);
for(i=0;i<NP_DM;i++)
Pdat.PID[i]=IDat.PID[i];
myfree(IDat.PID);
#endif
#endif
}
else
Pdat.PID=NULL;
if(flag_pos)
{
#ifdef SAME_REALTYPE
Pdat.Pos=IDat.Pos;
#else
Pdat.Pos=mymalloc(sizeof(HBTxyz)*NP_DM);
for(i=0;i<NP_DM;i++)
for(j=0;j<3;j++)
Pdat.Pos[i][j]=IDat.Pos[i][j];
myfree(IDat.Pos);
#endif
#ifdef CONVERT_LENGTH_MPC_KPC
for(i=0;i<NP_DM;i++)
for(j=0;j<3;j++)
Pdat.Pos[i][j]*=1000.;
#endif
#ifdef PERIODIC_BDR
for(i=0;i<NP_DM;i++)
for(j=0;j<3;j++)
Pdat.Pos[i][j]=position_modulus(Pdat.Pos[i][j]);
#endif
}
else
Pdat.Pos=NULL;
if(flag_vel)
{
#ifdef SAME_REALTYPE
Pdat.Vel=IDat.Vel;
#else
Pdat.Vel=mymalloc(sizeof(HBTxyz)*NP_DM);
for(i=0;i<NP_DM;i++)
for(j=0;j<3;j++)
Pdat.Vel[i][j]=IDat.Vel[i][j];
myfree(IDat.Vel);
#endif
}
else
Pdat.Vel=NULL;
}
