int main(int argc, char *argv[]){
char filename_root_out[256];
SID_init(&argc,&argv,NULL,NULL);
// Fetch user inputs
strcpy(filename_root_out,argv[1]);
// Read the run parameters
int i_read_start;
int i_read_stop;
int i_read_step;
int n_search;
int flag_fix_bridges;
int flag_compute_fragmented;
int flag_compute_ghosts;
read_trees_run_parameters(filename_root_out,
&i_read_start,
&i_read_stop,
&i_read_step,
&n_search,
&flag_fix_bridges,
&flag_compute_fragmented,
&flag_compute_ghosts);
// Default to scanning the whole range of snapshots when building forests
int n_search_forests=i_read_stop;
// Generate mapping
compute_forests(filename_root_out,n_search_forests);
SID_exit(ERROR_NONE);
}
int main(int argc, char *argv[]){
SID_init(&argc,&argv,NULL,NULL);
// Fetch user inputs
char filename_SSimPL_dir[MAX_FILENAME_LENGTH];
char filename_halo_version_root[MAX_FILENAME_LENGTH];
char filename_trees_name[MAX_FILENAME_LENGTH];
char filename_output_root[MAX_FILENAME_LENGTH];
strcpy(filename_SSimPL_dir, argv[1]);
strcpy(filename_halo_version_root,argv[2]);
strcpy(filename_trees_name, argv[3]);
strcpy(filename_output_root, argv[4]);
// Set the halo and tree filename roots
char filename_trees_root[MAX_FILENAME_LENGTH];
char filename_halos_root[MAX_FILENAME_LENGTH];
sprintf(filename_trees_root,"%s/trees/%s",filename_SSimPL_dir,filename_trees_name);
sprintf(filename_halos_root,"%s/halos/%s",filename_SSimPL_dir,filename_halo_version_root);
SID_log("Generating treenode markers & analysis of merger trees...",SID_LOG_OPEN|SID_LOG_TIMER);
// Perform analysis
tree_info *trees;
read_trees(filename_SSimPL_dir,
filename_halo_version_root,
filename_trees_name,
TREE_MODE_DEFAULT,
&trees);
// Read catalogs
read_trees_catalogs(trees,
filename_SSimPL_dir,
filename_halo_version_root,
READ_TREES_CATALOGS_BOTH);
// Loop over the two halo types
for(int i_type=0;i_type<2;i_type++){
// Initialize markers (just one-at-a-time to save RAM)
int mode;
if(i_type==0)
mode=PRECOMPUTE_TREENODE_MARKER_GROUPS;
else
mode=PRECOMPUTE_TREENODE_MARKER_SUBGROUPS;
// Compute markers
precompute_treenode_markers(trees,mode);
// Write markers
write_treenode_markers(trees,filename_output_root,mode);
// Free markers
free_precompute_treenode_markers(trees,mode);
}
// Clean-up
free_trees(&trees);
SID_log("Done.",SID_LOG_CLOSE);
SID_exit(ERROR_NONE);
}
int main(int argc, char *argv[]){
plist_info plist;
int snapshot;
char filename_in[256];
char filename_out[256];
SID_init(&argc,&argv,NULL,NULL);
/**********************/
/* Parse command line */
/**********************/
if(argc!=2){
fprintf(stderr,"\n syntax: %s gadget_file\n",argv[0]);
fprintf(stderr," ------\n\n");
return(ERROR_SYNTAX);
}
else{
strcpy(filename_in, argv[1]);
snapshot=atoi(argv[2]);
strcpy(filename_out,argv[3]);
strcat(filename_out,".csv");
}
SID_log("Converting GADGET file to .csv...",SID_LOG_OPEN|SID_LOG_TIMER,filename_in,filename_out);
/****************************************/
/* Read GADGET file into data structure */
/****************************************/
init_plist(&plist,NULL,GADGET_LENGTH,GADGET_MASS,GADGET_VELOCITY);
SID_log("Reading GADGET file {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,filename_in);
read_gadget_binary(filename_in,snapshot,&plist,READ_GADGET_DEFAULT);
SID_log("Done.",SID_LOG_CLOSE);
/********************/
/* Write ascii file */
/********************/
SID_log("Writing .csv file {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,filename_out);
write_gadget_csv(filename_out,&plist);
SID_log("Done.",SID_LOG_CLOSE);
/************/
/* Clean-up */
/************/
free_plist(&plist);
SID_log("Done.",SID_LOG_CLOSE);
return(ERROR_NONE);
}
int main(int argc, char *argv[]){
int n_search;
int i_halo;
char filename_SSimPL_root[MAX_FILENAME_LENGTH];
char filename_in[MAX_FILENAME_LENGTH];
char group_text_prefix[4];
int n_files;
int k_read;
int max_n_groups;
int l_read;
int n_groups;
int j_read;
int mode;
int n_groups_i;
int n_groups_j;
int j_halo;
int match;
int i_read;
int i_read_start;
int i_read_stop;
SID_fp fp_in;
SID_init(&argc,&argv,NULL,NULL);
// Fetch user inputs
strcpy(filename_SSimPL_root,argv[1]);
if(!strcmp(argv[2],"groups") || !strcmp(argv[2],"group"))
mode=MATCH_GROUPS;
else if(!strcmp(argv[2],"subgroups") || !strcmp(argv[2],"subgroup"))
mode=MATCH_SUBGROUPS;
else{
SID_log("Invalid mode selection {%s}. Should be 'group' or 'subgroup'.",SID_LOG_COMMENT,argv[2]);
SID_exit(ERROR_SYNTAX);
}
i_read=atoi(argv[3]);
j_read=atoi(argv[4]);
SID_log("Searching match information for halo #%d in file #%d of {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,i_halo,i_read,filename_SSimPL_root);
// Convert filename_root to filename
switch(mode){
case MATCH_SUBGROUPS:
sprintf(group_text_prefix,"sub");
break;
case MATCH_GROUPS:
sprintf(group_text_prefix,"");
break;
}
// Set the standard SSiMPL match file path
char filename_root_in[MAX_FILENAME_LENGTH];
sprintf(filename_root_in,"%s/trees/matches/",filename_SSimPL_root);
// Set the output file
char filename_base[MAX_FILENAME_LENGTH];
char filename_out[MAX_FILENAME_LENGTH];
sprintf(filename_base,filename_SSimPL_root);
if(!strcmp(&(filename_base[strlen(filename_base)-1]),"/"))
strcpy(&(filename_base[strlen(filename_base)-1]),"\0");
strip_path(filename_base);
sprintf(filename_out,"%s_%d_%d_2way_matches.txt",filename_base,i_read,j_read);
// Read header information
SID_log("Reading header information...",SID_LOG_OPEN);
sprintf(filename_in,"%s/%sgroup_matches_header.dat",filename_root_in,group_text_prefix);
SID_fopen(filename_in,"r",&fp_in);
SID_fread(&i_read_start,sizeof(int),1,&fp_in);SID_log("snap start =%d",SID_LOG_COMMENT,i_read_start);
SID_fread(&i_read_stop, sizeof(int),1,&fp_in);SID_log("snap stop =%d",SID_LOG_COMMENT,i_read_stop);
SID_fread(&n_search, sizeof(int),1,&fp_in);SID_log("search range=%d",SID_LOG_COMMENT,n_search);
SID_fread(&n_files, sizeof(int),1,&fp_in);SID_log("# of files =%d",SID_LOG_COMMENT,n_files);
for(k_read=0,max_n_groups=0;k_read<n_files;k_read++){
SID_fread(&l_read, sizeof(int),1,&fp_in);
SID_fread(&n_groups,sizeof(int),1,&fp_in);
SID_fseek(&fp_in, sizeof(int),n_groups,SID_SEEK_CUR);
if(mode==MATCH_GROUPS)
SID_fseek(&fp_in, sizeof(int),n_groups,SID_SEEK_CUR);
max_n_groups=MAX(max_n_groups,n_groups);
}
SID_log("Max # groups=%d",SID_LOG_COMMENT,max_n_groups);
SID_fclose(&fp_in);
SID_log("Done.",SID_LOG_CLOSE);
// Initialize some arrays
int *n_particles_i =(int *)SID_malloc(sizeof(int) *max_n_groups);
int *n_particles_j =(int *)SID_malloc(sizeof(int) *max_n_groups);
int *match_forward_ids =(int *)SID_malloc(sizeof(int) *max_n_groups);
size_t *match_forward_index =(size_t *)SID_malloc(sizeof(size_t)*max_n_groups);
float *match_forward_score =(float *)SID_malloc(sizeof(float) *max_n_groups);
char *match_forward_2way =(char *)SID_malloc(sizeof(char) *max_n_groups);
int *match_backward_ids =(int *)SID_malloc(sizeof(int) *max_n_groups);
size_t *match_backward_index=(size_t *)SID_malloc(sizeof(size_t)*max_n_groups);
float *match_backward_score=(float *)SID_malloc(sizeof(float) *max_n_groups);
char *match_backward_2way =(char *)SID_malloc(sizeof(char) *max_n_groups);
// Loop over all matching combinations
SID_log("Reading forward matches...",SID_LOG_OPEN|SID_LOG_TIMER);
SID_set_verbosity(SID_SET_VERBOSITY_DEFAULT);
read_matches(filename_root_in,
i_read,
j_read,
max_n_groups,
mode,
&n_groups_i,
&n_groups_j,
n_particles_i,
n_particles_j,
NULL,
NULL,
match_forward_ids,
match_forward_score,
match_forward_index,
match_forward_2way,
FALSE);
SID_log("Done.",SID_LOG_CLOSE);
SID_log("Processing backwards matches...",SID_LOG_OPEN|SID_LOG_TIMER);
read_matches(filename_root_in,
j_read,
i_read,
max_n_groups,
mode,
&n_groups_j,
&n_groups_i,
n_particles_j,
n_particles_i,
NULL,
NULL,
match_backward_ids,
match_backward_score,
match_backward_index,
match_backward_2way,
FALSE);
SID_log("Done.",SID_LOG_CLOSE);
// Open output file
FILE *fp_out;
fp_out=fopen(filename_out,"w");
int i_column=1;
fprintf(fp_out,"# Column (%02d): Halo index for snapshot %d\n", i_column++,i_read);
fprintf(fp_out,"# (%02d): Halo index for snapshot %d\n", i_column++,j_read);
fprintf(fp_out,"# (%02d): No. particles in snapshot %d\n", i_column++,i_read);
fprintf(fp_out,"# (%02d): No. particles in snapshot %d\n", i_column++,j_read);
fprintf(fp_out,"# (%02d): Forward match score\n", i_column++);
fprintf(fp_out,"# (%02d): Forward match score/min match score\n",i_column++);
fprintf(fp_out,"# (%02d): Backward match score\n", i_column++);
fprintf(fp_out,"# (%02d): Backward match score/min match score\n",i_column++);
for(int i_halo=0;i_halo<n_groups_i;i_halo++){
int j_halo=match_forward_ids[i_halo];
if(match_forward_2way[i_halo]){
if(j_halo<0 || j_halo>n_groups_j)
SID_trap_error("There's an invalid match id (ie. %d<0 || %d>%d) attached to a 2-way match!",ERROR_LOGIC,j_halo,j_halo,n_groups_j);
fprintf(fp_out,"%7d %7d %6d %6d %10.3le %10.3le %10.3le %10.3le\n",
i_halo,
j_halo,
n_particles_i[i_halo],
n_particles_j[j_halo],
match_forward_score[i_halo],
match_forward_score[i_halo]/minimum_match_score((double)n_particles_i[i_halo]),
match_backward_score[j_halo],
match_backward_score[j_halo]/minimum_match_score((double)n_particles_j[j_halo]));
}
}
fclose(fp_out);
// Clean-up
SID_free(SID_FARG n_particles_i);
SID_free(SID_FARG n_particles_j);
SID_free(SID_FARG match_forward_ids);
SID_free(SID_FARG match_forward_index);
SID_free(SID_FARG match_forward_score);
SID_free(SID_FARG match_forward_2way);
SID_free(SID_FARG match_backward_ids);
SID_free(SID_FARG match_backward_index);
SID_free(SID_FARG match_backward_score);
SID_free(SID_FARG match_backward_2way);
SID_log("Done.",SID_LOG_CLOSE);
SID_exit(ERROR_NONE);
}
int main(int argc, char *argv[]){
SID_init(&argc,&argv,NULL,NULL);
// Fetch user inputs
char filename_SSimPL_dir[MAX_FILENAME_LENGTH];
char filename_halo_version_root[MAX_FILENAME_LENGTH];
char filename_trees_root[MAX_FILENAME_LENGTH];
char filename_trees_name[MAX_FILENAME_LENGTH];
char filename_halos_root[MAX_FILENAME_LENGTH];
char filename_out_root[MAX_FILENAME_LENGTH];
strcpy(filename_SSimPL_dir, argv[1]);
strcpy(filename_halo_version_root,argv[2]);
strcpy(filename_trees_name, argv[3]);
double z_lo =(double)atof(argv[4]);
double z_hi =(double)atof(argv[5]);
double M_cut_min =(double)atof(argv[6]);
strcpy(filename_out_root, argv[7]);
// Set some filenames
sprintf(filename_trees_root,"%s/trees/%s",filename_SSimPL_dir,filename_trees_name);
sprintf(filename_halos_root,"%s/halos/%s",filename_SSimPL_dir,filename_halo_version_root);
SID_log("Creating a catalog matched across redshifts z_lo~%lf and z_hi~%lf...",SID_LOG_OPEN|SID_LOG_TIMER,z_lo,z_hi);
// Perform analysis
tree_info *trees;
read_trees(filename_SSimPL_dir,
filename_halo_version_root,
filename_trees_name,
TREE_MODE_DEFAULT|TREE_READ_EXTENDED_POINTERS,
&trees);
// Read ancillary data
read_trees_catalogs(trees,READ_TREES_CATALOGS_GROUPS|READ_TREES_CATALOGS_SUBGROUPS);
// Determine which snapshots best match the given redshifts
int i_z_lo=find_treesnap_z(trees,z_lo);
int i_z_hi=find_treesnap_z(trees,z_hi);
// Generate two catalogs
SID_log("Compiling catalogs...",SID_LOG_OPEN|SID_LOG_TIMER);
for(int i_cat=0;i_cat<2;i_cat++){
char filename_out[MAX_FILENAME_LENGTH];
switch(i_cat){
case 0:
SID_log("Processing group catalog...",SID_LOG_OPEN);
sprintf(filename_out,"%s_groups.txt",filename_out_root);
break;
case 1:
SID_log("Processing subgroup catalog...",SID_LOG_OPEN);
sprintf(filename_out,"%s_subgroups.txt",filename_out_root);
break;
}
// Open file and write header
FILE *fp_out =fopen(filename_out,"w");
int i_column=1;
fprintf(fp_out,"# Catalog matched from z_hi=%lf to z_lo=%lf\n",trees->z_list[i_z_hi],trees->z_list[i_z_lo]);
fprintf(fp_out,"# SSiMPL_dir ={%s}\n",filename_SSimPL_dir);
fprintf(fp_out,"# halo_version={%s}\n",filename_halo_version_root);
fprintf(fp_out,"# tree_version={%s}\n",filename_trees_name);
fprintf(fp_out,"#\n");
if(i_cat==0){
fprintf(fp_out,"# Column (%02d): FoF index (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): FoF index (z_lo)\n",i_column++);
}
else{
fprintf(fp_out,"# Column (%02d): subgroup index (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): subgroup index (z_lo)\n",i_column++);
fprintf(fp_out,"# (%02d): FoF index (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): FoF index (z_lo)\n",i_column++);
}
fprintf(fp_out,"# (%02d): n_particles (z_hi)\n",i_column++);
if(i_cat==0){
fprintf(fp_out,"# (%02d): n_subgroups (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): n_subgroups (z_lo)\n",i_column++);
fprintf(fp_out,"# (%02d): sig_v_1D [km/s] (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): sig_v_1D [km/s] (z_lo)\n",i_column++);
fprintf(fp_out,"# (%02d): sig_v_1Dp [km/s] (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): sig_v_1Dp [km/s] (z_lo)\n",i_column++);
}
else{
fprintf(fp_out,"# (%02d): M_vir_sub (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): M_vir_sub (z_lo)\n",i_column++);
}
fprintf(fp_out,"# (%02d): M_vir_FoF (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): M_vir_FoF (z_lo)\n",i_column++);
fprintf(fp_out,"# (%02d): x (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): y (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): z (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): x (z_lo)\n",i_column++);
fprintf(fp_out,"# (%02d): y (z_lo)\n",i_column++);
fprintf(fp_out,"# (%02d): z (z_lo)\n",i_column++);
fprintf(fp_out,"# (%02d): v_x (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): v_y (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): v_z (z_hi)\n",i_column++);
fprintf(fp_out,"# (%02d): v_x (z_lo)\n",i_column++);
fprintf(fp_out,"# (%02d): v_y (z_lo)\n",i_column++);
fprintf(fp_out,"# (%02d): v_z (z_lo)\n",i_column++);
// Write catalog
tree_node_info *current;
halo_properties_info **group_properties =(halo_properties_info **)ADaPS_fetch(trees->data,"properties_groups");
halo_properties_info **subgroup_properties=(halo_properties_info **)ADaPS_fetch(trees->data,"properties_subgroups");
if(i_cat==0)
current=trees->first_neighbour_groups[i_z_hi];
else
current=trees->first_neighbour_subgroups[i_z_hi];
while(current!=NULL){
tree_node_info *current_subgroup;
tree_node_info *current_group;
halo_properties_info *current_properties;
halo_properties_info *current_group_properties;
halo_properties_info *current_subgroup_properties;
if(i_cat==0){
current_subgroup =NULL;
current_group =current;
current_group_properties =&(group_properties[current_group->snap_tree][current_group->neighbour_index]);
current_subgroup_properties=&(subgroup_properties[current->snap_tree][current->neighbour_index]);
current_properties =current_group_properties;
}
else{
current_subgroup =current;
current_group =current->parent_top;
current_group_properties =&(group_properties[current_group->snap_tree][current_group->neighbour_index]);
current_subgroup_properties=&(subgroup_properties[current->snap_tree][current->neighbour_index]);
current_properties =current_subgroup_properties;
}
if(current_properties->M_vir>=M_cut_min){
tree_node_info *matched;
int flag_exact=find_treenode_snap_equals_given(trees,current,i_z_lo,&matched,TREE_PROGENITOR_ORDER_N_PARTICLES_PEAK);
if(matched!=NULL && flag_exact){
int n_sub_lo;
int n_sub_hi;
tree_node_info *matched_group;
tree_node_info *matched_subgroup;
halo_properties_info *matched_group_properties;
halo_properties_info *matched_subgroup_properties;
double current_group_sigma_v=0.;
double matched_group_sigma_v=0.;
if(i_cat==0){
double v_mean;
matched_subgroup =NULL;
matched_group =matched;
matched_subgroup_properties=NULL;
matched_group_properties =&(group_properties[matched_group->snap_tree][matched_group->neighbour_index]);
tree_node_info *current_j;
// Compute 1D velocity dispersion for current group
current_j=current_group->substructure_first;
v_mean =0.;
n_sub_hi =0;
while(current_j!=NULL){
double M_i=subgroup_properties[current_j->snap_tree][current_j->neighbour_index].M_vir;
if(M_i>M_cut_min){
float v_i=subgroup_properties[current_j->snap_tree][current_j->neighbour_index].velocity_COM[0];
v_mean+=v_i;
n_sub_hi++;
}
current_j=current_j->substructure_next;
}
current_j=current_group->substructure_first;
current_group_sigma_v=0.;
if(n_sub_hi>1){
v_mean/=(double)n_sub_hi;
while(current_j!=NULL){
double M_i=subgroup_properties[current_j->snap_tree][current_j->neighbour_index].M_vir;
if(M_i>M_cut_min){
float v_i=subgroup_properties[current_j->snap_tree][current_j->neighbour_index].velocity_COM[0];
current_group_sigma_v+=pow(v_i-v_mean,2.);
}
current_j=current_j->substructure_next;
}
current_group_sigma_v=sqrt(current_group_sigma_v/(double)(n_sub_hi-1));
}
// Compute 1D velocity dispersion for matched group
current_j=matched_group->substructure_first;
v_mean =0.;
n_sub_lo =0;
while(current_j!=NULL){
double M_i=subgroup_properties[current_j->snap_tree][current_j->neighbour_index].M_vir;
if(M_i>M_cut_min){
float v_i=subgroup_properties[current_j->snap_tree][current_j->neighbour_index].velocity_COM[0];
v_mean+=v_i;
n_sub_lo++;
}
current_j=current_j->substructure_next;
}
current_j=matched_group->substructure_first;
matched_group_sigma_v=0.;
if(n_sub_lo>1){
v_mean/=(double)n_sub_lo;
while(current_j!=NULL){
double M_i=subgroup_properties[current_j->snap_tree][current_j->neighbour_index].M_vir;
if(M_i>M_cut_min){
float v_i=subgroup_properties[current_j->snap_tree][current_j->neighbour_index].velocity_COM[0];
matched_group_sigma_v+=pow(v_i-v_mean,2.);
}
current_j=current_j->substructure_next;
}
matched_group_sigma_v=sqrt(matched_group_sigma_v/(double)(n_sub_lo-1));
}
}
else{
matched_subgroup =matched;
matched_group =matched_subgroup->parent_top;
matched_subgroup_properties=&(subgroup_properties[matched_subgroup->snap_tree][matched_subgroup->neighbour_index]);
matched_group_properties =&(group_properties[matched_group->snap_tree][matched_group->neighbour_index]);
}
if(i_cat==0)
fprintf(fp_out,"%7d %7d %6d %5d %5d %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le\n",
current_group->neighbour_index,
matched_group->neighbour_index,
current_group_properties->n_particles,
n_sub_hi,
n_sub_lo,
current_group_sigma_v,
matched_group_sigma_v,
current_group_properties->sigma_v,
matched_group_properties->sigma_v,
current_group_properties->M_vir,
matched_group_properties->M_vir,
current_group_properties->position_MBP[0],
current_group_properties->position_MBP[1],
current_group_properties->position_MBP[2],
matched_group_properties->position_MBP[0],
matched_group_properties->position_MBP[1],
matched_group_properties->position_MBP[2],
current_group_properties->velocity_COM[0],
current_group_properties->velocity_COM[1],
current_group_properties->velocity_COM[2],
matched_group_properties->velocity_COM[0],
matched_group_properties->velocity_COM[1],
matched_group_properties->velocity_COM[2]);
else
fprintf(fp_out,"%7d %7d %7d %7d %6d %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le %10.3le\n",
current_subgroup->neighbour_index,
matched_subgroup->neighbour_index,
current_group->neighbour_index,
matched_group->neighbour_index,
current_subgroup_properties->n_particles,
current_subgroup_properties->M_vir,
matched_subgroup_properties->M_vir,
current_group_properties->M_vir,
matched_group_properties->M_vir,
current_subgroup_properties->position_MBP[0],
current_subgroup_properties->position_MBP[1],
current_subgroup_properties->position_MBP[2],
matched_subgroup_properties->position_MBP[0],
matched_subgroup_properties->position_MBP[1],
matched_subgroup_properties->position_MBP[2],
current_subgroup_properties->velocity_COM[0],
current_subgroup_properties->velocity_COM[1],
current_subgroup_properties->velocity_COM[2],
matched_subgroup_properties->velocity_COM[0],
matched_subgroup_properties->velocity_COM[1],
matched_subgroup_properties->velocity_COM[2]);
}
}
current=current->next_neighbour;
}
fclose(fp_out);
SID_log("Done.",SID_LOG_CLOSE);
}
SID_log("Done.",SID_LOG_CLOSE);
// Clean-up
free_trees(&trees);
SID_log("Done.",SID_LOG_CLOSE);
SID_exit(ERROR_NONE);
}
int main(int argc, char *argv[]){
SID_init(&argc,&argv,NULL,NULL);
char filename_cosmology[MAX_FILENAME_LENGTH];
char paramterization[MAX_FILENAME_LENGTH];
double log_M_min =atof(argv[1]);
double log_M_max =atof(argv[2]);
int n_M_bins =atoi(argv[3]);
double redshift =atof(argv[4]);
strcpy(filename_cosmology,argv[5]);
strcpy(paramterization, argv[6]);
SID_log("Constructing mass function between log(M)=%5.3lf->%5.3lf at z=%5.3lf...",SID_LOG_OPEN,log_M_min,log_M_max,redshift);
// Initialize cosmology
cosmo_info *cosmo=NULL;
read_gbpCosmo_file(&cosmo,filename_cosmology);
// Decide which parameterization we are going to use
int select_flag;
char mfn_text[32];
if(!strcmp(paramterization,"JENKINS")){
sprintf(mfn_text,"Jenkins");
select_flag=MF_JENKINS;
}
else if(!strcmp(paramterization,"PS")){
sprintf(mfn_text,"Press & Schechter");
select_flag=MF_PS;
}
else if(!strcmp(paramterization,"ST")){
sprintf(mfn_text,"Sheth & Tormen");
select_flag=MF_ST;
}
else
SID_trap_error("Invalid parameterization selected {%s}. Should be {JENKINS,PS or ST}.",ERROR_SYNTAX,paramterization);
// Create output filename
char filename_out[MAX_FILENAME_LENGTH];
char redshift_text[64];
char *cosmology_name=(char *)ADaPS_fetch(cosmo,"name");
float_to_text(redshift,3,redshift_text);
sprintf(filename_out,"mass_function_z%s_%s_%s.txt",redshift_text,cosmology_name,paramterization);
// Open file and write header
FILE *fp_out=NULL;
fp_out=fopen(filename_out,"w");
int i_column=1;
fprintf(fp_out,"# Mass function (%s) for %s cosmology at z=%lf\n",mfn_text,filename_cosmology,redshift);
fprintf(fp_out,"# \n");
fprintf(fp_out,"# Column (%02d): log M [h^-1 M_sol]\n", i_column++);
fprintf(fp_out,"# (%02d): Mass function [(h^{-1} Mpc]^{-3} per dlogM]\n", i_column++);
fprintf(fp_out,"# (%02d): Cumulative Mass function(>M) [(h^{-1} Mpc]^{-3}]\n",i_column++);
// Create the mass function
SID_log("Writing results to {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,filename_out);
pcounter_info pcounter;
SID_init_pcounter(&pcounter,n_M_bins,10);
double h_Hubble =((double *)ADaPS_fetch(cosmo,"h_Hubble"))[0];
double mass_factor=M_SOL/h_Hubble;
double MFct_factor=pow(M_PER_MPC,3.0);
for(int i_bin=0;i_bin<n_M_bins;i_bin++){
double log_M;
if(i_bin==0)
log_M=log_M_min;
else if(i_bin==(n_M_bins-1))
log_M=log_M_max;
else
log_M=log_M_min+(((double)(i_bin))/((double)(n_M_bins-1)))*(log_M_max-log_M_min);
fprintf(fp_out,"%le %le %le\n",log_M,
MFct_factor*mass_function (mass_factor*take_alog10(log_M),redshift,&cosmo,select_flag),
MFct_factor*mass_function_cumulative(mass_factor*take_alog10(log_M),redshift,&cosmo,select_flag));
SID_check_pcounter(&pcounter,i_bin);
}
fclose(fp_out);
SID_log("Done.",SID_LOG_CLOSE);
// Clean-up
free_cosmo(&cosmo);
SID_log("Done.",SID_LOG_CLOSE);
SID_exit(ERROR_NONE);
}
int main(int argc, char *argv[]){
char filename_root[256];
char filename_properties[256];
char filename_indices[256];
char filename_out[256];
char prefix_text[5];
FILE *fp_properties=NULL;
FILE *fp_profiles =NULL;
FILE *fp_out =NULL;
int i_file;
int n_files;
int n_groups_all;
int i_group;
int i_group_selected;
int i_profile;
int flag_process_group;
int snap_number;
int n_groups_properties;
int n_groups_profiles;
halo_properties_info properties;
halo_profile_info profile;
float lambda,v_c;
float offset_COM;
float r_min,r_max;
SID_init(&argc,&argv,NULL,NULL);
strcpy(filename_root, argv[1]);
snap_number =atoi(argv[2]);
i_group_selected=atoi(argv[3]);
if(i_group_selected<0){
flag_process_group=TRUE;
i_group_selected*=-1;
sprintf(prefix_text,"");
}
else{
flag_process_group=FALSE;
sprintf(prefix_text,"sub");
}
if(SID.I_am_Master){
sprintf(filename_indices,"%s_%03d.catalog_%sgroups_indices",filename_root,snap_number,prefix_text);
FILE *fp_in;
if((fp_in=fopen(filename_indices,"r"))==NULL)
SID_trap_error("Could not open file {%s}.",ERROR_IO_OPEN,filename_indices);
int i_file,n_files,n_groups,n_groups_all;
fread(&i_file, sizeof(int),1,fp_in);
fread(&n_files, sizeof(int),1,fp_in);
fread(&n_groups, sizeof(int),1,fp_in);
fread(&n_groups_all,sizeof(int),1,fp_in);
int n_particles_i;
for(i_group=0;i_group<i_group_selected;i_group++){
fread(&n_particles_i,sizeof(int),1,fp_in);
fseeko(fp_in,(off_t)(sizeof(size_t)*n_particles_i),SEEK_CUR);
}
fread(&n_particles_i,sizeof(int),1,fp_in);
fprintf(stderr,"n_particles=%d\n",n_particles_i);
int i_particle;
for(i_particle=0;i_particle<n_particles_i;i_particle++){
size_t index_i;
fread(&index_i,sizeof(size_t),1,fp_in);
fprintf(stderr,"%4d %lld\n",i_particle,index_i);
}
fclose(fp_in);
}
SID_exit(ERROR_NONE);
}
int main(int argc, char *argv[]){
double redshift;
char filename_in[MAX_FILENAME_LENGTH];
char filename_out[MAX_FILENAME_LENGTH];
char filename_cosmology[MAX_FILENAME_LENGTH];
double box_size;
double lM_min,dlM;
char *line=NULL;
size_t line_length=0;
int M_column;
int n_bins;
int flag_log;
// Initialization -- MPI etc.
SID_init(&argc,&argv,NULL,NULL);
if(argc!=11)
SID_trap_error("Incorrect syntax.",ERROR_SYNTAX);
// Parse arguments
strcpy(filename_in, argv[1]);
strcpy(filename_out,argv[2]);
redshift=(double)atof(argv[3]);
strcpy(filename_cosmology,argv[4]);
box_size=(double)atof(argv[5]);
M_column=(int) atoi(argv[6]);
flag_log=(int) atoi(argv[7]);
lM_min =(double)atof(argv[8]);
dlM =(double)atof(argv[9]);
n_bins =(int) atoi(argv[10]);
SID_log("Producing a mass function for ascii file {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,filename_in);
// Initialize cosmology
cosmo_info *cosmo;
read_gbpCosmo_file(&cosmo,filename_cosmology);
double h_Hubble=((double *)ADaPS_fetch(cosmo,"h_Hubble"))[0];
// Open file
FILE *fp_in;
if((fp_in=fopen(filename_in,"r"))==NULL)
SID_trap_error("Could not open {%s} for reading.",ERROR_IO_OPEN,filename_in);
// Allocate memory for the data. Read it and sort it in ascending order
SID_log("Reading data...",SID_LOG_OPEN|SID_LOG_TIMER);
int n_data_in=count_lines_data(fp_in);
SID_log("(%d items)...",SID_LOG_CONTINUE,n_data_in);
double *data =(double *)malloc(sizeof(double)*n_data_in);
int n_data=0;
for(int i=0;i<n_data_in;i++){
double data_in;
grab_next_line_data(fp_in,&line,&line_length);
grab_double(line,M_column,&data_in);
if(!flag_log)
data_in=take_log10(data_in);
if(data_in>=lM_min)
data[n_data++]=data_in;
}
SID_log("(%d will be used)...",SID_LOG_CONTINUE,n_data);
fclose(fp_in);
SID_free(SID_FARG line);
SID_log("Done.",SID_LOG_CLOSE);
// Perform sort
SID_log("Sorting data...",SID_LOG_OPEN|SID_LOG_TIMER);
merge_sort(data,n_data,NULL,SID_DOUBLE,SORT_INPLACE_ONLY,SORT_COMPUTE_INPLACE);
SID_log("Done.",SID_LOG_CLOSE);
// Compile histogram
SID_log("Computing mass function...",SID_LOG_OPEN|SID_LOG_TIMER);
double *bin =(double *)SID_malloc(sizeof(double)*(n_bins+1));
double *bin_median=(double *)SID_malloc(sizeof(double)*n_bins);
int *hist =(int *)SID_calloc(sizeof(int) *n_bins);
double lM_bin_min=lM_min;
double lM_bin_max=lM_min;
int i_data_lo=-1;
int i_data_hi=-1;
int i_bin =0;
int i_data=0;
for(i_bin=0;i_bin<n_bins;i_bin++){
lM_bin_min=lM_bin_max;
lM_bin_max=lM_min+((double)(i_bin+1))*dlM;
bin[i_bin]=lM_bin_min;
i_data_lo=i_data;
i_data_hi=i_data;
while(data[i_data]<lM_bin_max && i_data<n_data){
hist[i_bin]++;
i_data_hi=i_data;
i_data++;
if(i_data>=n_data) break;
}
int i_data_mid=(i_data_lo+i_data_hi)/2;
if(hist[i_bin]>0){
if(hist[i_bin]%2)
bin_median[i_bin]=data[i_data_mid];
else
bin_median[i_bin]=0.5*(data[i_data_mid]+data[i_data_mid+1]);
}
else
bin_median[i_bin]=0.5*(lM_bin_max+lM_bin_min);
}
bin[i_bin]=lM_bin_max;
SID_log("Done.",SID_LOG_CLOSE);
// Write mass function
FILE *fp_out;
if((fp_out=fopen(filename_out,"w"))==NULL){
fprintf(stderr,"Error opening output file {%s}.\n",filename_out);
SID_free(SID_FARG data);
return(1);
}
SID_log("Writing results to {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,filename_out);
double box_volume=box_size*box_size*box_size;
fprintf(fp_out,"# Mass function for column %d in {%s}\n",M_column,filename_in);
fprintf(fp_out,"# Column (01): M_lo [source units]\n");
fprintf(fp_out,"# (02): M_median [source units]\n");
fprintf(fp_out,"# (03): M_hi [source units]\n");
fprintf(fp_out,"# (04): No. in bin\n");
fprintf(fp_out,"# (05): MFn (per unit volume, per dlogM)\n");
fprintf(fp_out,"# (06): +/- MFn\n");
fprintf(fp_out,"# (07): Sheth & Tormen MFn\n");
fprintf(fp_out,"# (08): Watson MFn\n");
fprintf(fp_out,"# (09): No. w/ M>M_lo\n");
fprintf(fp_out,"# (10): Cumulative MFn (per unit volume)\n");
fprintf(fp_out,"# (11): +/- Cumulative MFn\n");
fprintf(fp_out,"# (12): Sheth & Tormen Cumulative MFn\n");
fprintf(fp_out,"# (13): Watson Cumulative MFn\n");
double M_sol_inv_h=M_SOL/h_Hubble;
double Mpc_inv_h =M_PER_MPC/h_Hubble;
for(int i=0;i<n_bins;i++){
double dn_dlogM_theory_1=mass_function(take_alog10(bin_median[i])*M_sol_inv_h,
redshift,
&cosmo,
MF_ST)*pow(Mpc_inv_h,3.0);
double n_theory_1=mass_function_cumulative(take_alog10(bin[i])*M_sol_inv_h,
redshift,
&cosmo,
MF_ST)*pow(Mpc_inv_h,3.0);
double dn_dlogM_theory_2=mass_function(take_alog10(bin_median[i])*M_sol_inv_h,
redshift,
&cosmo,
MF_WATSON)*pow(Mpc_inv_h,3.0);
double n_theory_2=mass_function_cumulative(take_alog10(bin[i])*M_sol_inv_h,
redshift,
&cosmo,
MF_WATSON)*pow(Mpc_inv_h,3.0);
// Compute cumulative histogram
int cumulative_hist=0;
for(int j_bin=i;j_bin<n_bins;j_bin++)
cumulative_hist+=hist[j_bin];
fprintf(fp_out,"%11.4le %11.4le %11.4le %6d %11.4le %11.4le %10.4le %10.4le %6d %10.4le %10.4le %10.4le %10.4le\n",
bin[i],
bin_median[i],
bin[i+1],
hist[i],
(double)(hist[i])/(box_volume*dlM),
sqrt((double)(hist[i]))/(box_volume*dlM),
dn_dlogM_theory_1,dn_dlogM_theory_2,
cumulative_hist,
(double)(cumulative_hist)/box_volume,
sqrt((double)(cumulative_hist))/box_volume,
n_theory_1,n_theory_2);
}
fclose(fp_out);
SID_log("Done.",SID_LOG_CLOSE);
// Free allocated memory
SID_free(SID_FARG data);
SID_free(SID_FARG bin);
SID_free(SID_FARG bin_median);
SID_free(SID_FARG hist);
SID_log("Done.",SID_LOG_CLOSE);
SID_exit(ERROR_NONE);
}
int main(int argc, char *argv[]){
SID_init(&argc,&argv,NULL,NULL);
SID_log("Constructing match catalog...",SID_LOG_OPEN|SID_LOG_TIMER);
// Parse arguments
char filename_catalog_root[MAX_FILENAME_LENGTH];
char filename_matches_root[MAX_FILENAME_LENGTH];
char filename_out[MAX_FILENAME_LENGTH];
char prefix_text[32];
int flag_matches_type;
int i_read;
int j_read;
int catalog_read_mode;
int matches_read_mode;
strcpy(filename_catalog_root,argv[1]);
strcpy(filename_matches_root,argv[2]);
flag_matches_type =atoi(argv[3]);
strcpy(prefix_text, argv[4]);
i_read =atoi(argv[5]);
j_read =atoi(argv[6]);
strcpy(filename_out, argv[7]);
if(!strcpy(prefix_text,"subgroup") ||
!strcpy(prefix_text,"subgroups") ||
!strcpy(prefix_text,"sub")){
sprintf(prefix_text,"sub");
catalog_read_mode=READ_CATALOG_SUBGROUPS|READ_CATALOG_PROPERTIES;
matches_read_mode=MATCH_SUBGROUPS;
}
else if(!strcpy(prefix_text,"group") ||
!strcpy(prefix_text,"groups")){
sprintf(prefix_text,"");
catalog_read_mode=READ_CATALOG_GROUPS|READ_CATALOG_PROPERTIES;
matches_read_mode=MATCH_GROUPS;
}
else
SID_trap_error("Invalid catalog type (%s).",ERROR_SYNTAX,prefix_text);
// Set filenames
char filename_cat1[MAX_FILENAME_LENGTH];
char filename_cat2[MAX_FILENAME_LENGTH];
sprintf(filename_cat1,"%s_%03d.catalog_%sgroups_properties",filename_catalog_root,prefix_text,i_read);
sprintf(filename_cat2,"%s_%03d.catalog_%sgroups_properties",filename_catalog_root,prefix_text,j_read);
// Contents of the halo properties structure
//struct halo_properties_info{
// long long id_MBP; // ID of most bound particle in structure
// int n_particles; // Number of particles in the structure
// float position_COM[3]; // Centre-of-mass position [Mpc/h]
// float position_MBP[3]; // Most bound particle position [Mpc/h]
// float velocity_COM[3]; // Centre-of-mass velocity [km/s]
// float velocity_MBP[3]; // Most bound particle velocity [km/s]
// double M_vir; // Bryan & Norman (ApJ 495, 80, 1998) virial mass [M_sol/h]
// float R_vir; // Virial radius [Mpc/h]
// float R_halo; // Distance of last halo particle from MBP [Mpc/h]
// float R_max; // Radius of maximum circular velocity [Mpc/h]
// float V_max; // Maximum circular velocity [km/s]
// float sigma_v; // Total 3D velocity dispersion [km/s]
// float spin[3]; // Specific angular momentum vector [Mpc/h*km/s]
// float q_triaxial; // Triaxial shape parameter q=b/a
// float s_triaxial; // Triaxial shape parameter s=c/a
// float shape_eigen_vectors[3][3]; // Normalized triaxial shape eigenvectors
//};
// Read matches
int *n_subgroups =NULL;
int *n_groups =NULL;
int *n_particles_i=NULL;
int *n_particles_j=NULL;
int *match_ids =NULL;
float *match_score =NULL;
size_t *match_index =NULL;
int n_halos_i;
int n_halos_j;
int n_files;
int n_subgroups_max;
int n_groups_max;
int n_halos_max;
read_matches_header(filename_matches_root,
0,
MAX(i_read,j_read),
1,
&n_files,
&n_subgroups,
&n_groups,
&n_subgroups_max,
&n_groups_max,
&n_halos_max);
read_matches(filename_matches_root,
i_read,
j_read,
n_halos_max,
matches_read_mode,
&n_halos_i,
&n_halos_j,
n_particles_i,
n_particles_j,
NULL,
NULL,
match_ids,
match_score,
match_index,
NULL,
FALSE);
// Create a storage array mapping the indices of the second catalog
// to those of the halos they are matched to in the first catalog
int i_halo;
int j_halo;
int *storage_index;
storage_index=(int *)SID_malloc(sizeof(int)*n_halos_j);
for(j_halo=0;j_halo<n_halos_j;j_halo++)
storage_index[j_halo]=-1;
for(i_halo=0,j_halo=0;j_halo<n_halos_j && i_halo<n_halos_i;j_halo++){
while(match_ids[match_index[i_halo]]<j_halo && i_halo<(n_halos_i-1)) i_halo++;
if(match_ids[match_index[i_halo]]<j_halo) i_halo++;
if(match_ids[match_index[i_halo]]==j_halo)
storage_index[j_halo]=match_index[i_halo];
}
// Open catalog files
fp_catalog_info fp_properties_i;
fp_catalog_info fp_properties_j;
fopen_catalog(filename_catalog_root,
i_read,
catalog_read_mode,
&fp_properties_i);
fopen_catalog(filename_catalog_root,
j_read,
catalog_read_mode,
&fp_properties_j);
// Read catalogs
halo_properties_info *properties_i;
halo_properties_info *properties_j;
properties_i =(halo_properties_info *)SID_malloc(sizeof(halo_properties_info)*n_halos_i);
properties_j =(halo_properties_info *)SID_malloc(sizeof(halo_properties_info)*n_halos_i);
for(i_halo=0;i_halo<n_halos_i;i_halo++)
fread_catalog_file(&fp_properties_i,NULL,NULL,&(properties_i[i_halo]),NULL,i_halo);
for(j_halo=0;j_halo<n_halos_j;j_halo++){
if(storage_index[j_halo]>=0)
fread_catalog_file(&fp_properties_j,NULL,NULL,&(properties_j[storage_index[j_halo]]),NULL,j_halo);
}
fclose_catalog(&fp_properties_i);
fclose_catalog(&fp_properties_j);
// Write results
int i_column=0;
FILE *fp_out;
fp_out=fopen(filename_out,"w");
fprintf(fp_out,"# Catalog for matches {root %s} and catalog {root %s}; snap No. %d to %d.\n",
filename_matches_root,
filename_catalog_root,
i_read,j_read);
fprintf(fp_out,"# Columns:(%02d) id (catalog No. 1)\n", i_column++);
fprintf(fp_out,"# (%02d) id (catalog No. 2)\n", i_column++);
fprintf(fp_out,"# (%02d) M (catalog No. 1) [M_sol/h]\n",i_column++);
fprintf(fp_out,"# (%02d) M (catalog No. 2) [M_sol/h]\n",i_column++);
fprintf(fp_out,"# (%02d) x (catalog No. 1) [Mpc/h]\n", i_column++);
fprintf(fp_out,"# (%02d) y (catalog No. 1) [Mpc/h]\n", i_column++);
fprintf(fp_out,"# (%02d) z (catalog No. 1) [Mpc/h]\n", i_column++);
fprintf(fp_out,"# (%02d) x (catalog No. 2) [Mpc/h]\n", i_column++);
fprintf(fp_out,"# (%02d) y (catalog No. 2) [Mpc/h]\n", i_column++);
fprintf(fp_out,"# (%02d) z (catalog No. 2) [Mpc/h]\n", i_column++);
for(i_halo=0;i_halo<n_halos_i;i_halo++){
fprintf(fp_out,"%10d %10d %10.4le %10.4le %10.4f %10.4f %10.4f %10.4f %10.4f %10.4f\n",
i_halo,
match_ids[i_halo],
properties_i[i_halo].M_vir,
properties_j[i_halo].M_vir,
properties_i[i_halo].position_COM[0],
properties_i[i_halo].position_COM[1],
properties_i[i_halo].position_COM[2],
properties_j[i_halo].position_COM[0],
properties_j[i_halo].position_COM[1],
properties_j[i_halo].position_COM[2]);
}
fclose(fp_out);
// Clean-up
SID_free(SID_FARG n_subgroups);
SID_free(SID_FARG n_groups);
SID_free(SID_FARG n_particles_i);
SID_free(SID_FARG n_particles_j);
SID_free(SID_FARG properties_i);
SID_free(SID_FARG properties_j);
SID_free(SID_FARG match_ids);
SID_free(SID_FARG match_score);
SID_free(SID_FARG match_index);
SID_free(SID_FARG storage_index);
SID_log("Done.",SID_LOG_CLOSE);
SID_exit(ERROR_NONE);
}
int main(int argc, char *argv[]){
plist_info plist;
char filename_in_root[256];
char filename_out_root[256];
char filename_in[256];
char filename_out[256];
int subsample_factor;
int i_snap,i_file,j_file;
int n_files;
unsigned int n_local[N_GADGET_TYPE];
int i_type;
size_t i_particle,j_particle;
FILE *fp;
FILE *fp_out;
int record_length_in;
int record_length_out;
GBPREAL position[3];
GBPREAL velocity[3];
int ID_int;
RNG_info RNG;
int seed_init=10463743;
int seed;
GBPREAL RNG_max;
long long n_all_keep[N_GADGET_TYPE];
long long n_all_init[N_GADGET_TYPE];
unsigned int n_all_high_word[N_GADGET_TYPE];
unsigned int n_all[N_GADGET_TYPE];
double mass_array[N_GADGET_TYPE];
int n_keep_total;
int n_init_total;
int record_length;
int flag_long_ids;
int id_in_int;
long long id_in_long;
int n_groups;
SID_init(&argc,&argv,NULL,NULL);
// Parse command line
if(argc!=4){
fprintf(stderr,"\n syntax: %s filename_in_root snapshot_number subsample_factor\n",argv[0]);
fprintf(stderr," ------\n\n");
return(ERROR_SYNTAX);
}
else{
strcpy(filename_in_root, argv[1]);
i_snap =atoi(argv[2]);
subsample_factor=atoi(argv[3]);
}
sprintf(filename_out_root,"%s_subsample",filename_in_root);
RNG_max=1./(GBPREAL)(subsample_factor);
SID_log("Subsampling GADGET file by a factor of %d...",SID_LOG_OPEN,subsample_factor);
// Grab info from first header
// Read the header and determine the input file-format
gadget_read_info fp_gadget;
int flag_filefound=init_gadget_read(filename_in_root,i_snap,&fp_gadget);
int flag_multifile=fp_gadget.flag_multifile;
int flag_file_type=fp_gadget.flag_file_type;
gadget_header_info header =fp_gadget.header;
if(!flag_filefound)
SID_trap_error("File not found.",ERROR_LOGIC);
if(flag_filefound)
n_files =header.n_files;
else
n_files=0;
if(n_files>0){
init_seed_from_clock(&seed_init);
SID_log("Seed=%d",SID_LOG_COMMENT,seed_init);
SID_log("Counting particles in %d files...",SID_LOG_OPEN|SID_LOG_TIMER,n_files);
for(i_type=0;i_type<N_GADGET_TYPE;i_type++)
n_all_keep[i_type]=0;
for(i_file=SID.My_rank,j_file=0;j_file<n_files;i_file+=SID.n_proc,j_file+=SID.n_proc){
if(n_files>1)
SID_log("Processing file(s) %d->%d...",SID_LOG_OPEN,j_file,MIN(j_file+SID.n_proc-1,n_files-1));
if(i_file<n_files){
set_gadget_filename(&fp_gadget,i_file,filename_in);
fp=fopen(filename_in,"r");
fread_verify(&record_length_in,sizeof(int),1,fp);
fread_verify(&header,sizeof(gadget_header_info),1,fp);
fread_verify(&record_length_out,sizeof(int),1,fp);
seed=seed_init+1387*i_file;
init_RNG(&seed,&RNG,RNG_DEFAULT);
for(i_type=0;i_type<N_GADGET_TYPE;i_type++){
for(j_particle=0;j_particle<header.n_file[i_type];j_particle++){
if(random_number(&RNG)<=RNG_max)
n_all_keep[i_type]++;
}
}
free_RNG(&RNG);
fclose(fp);
}
if(n_files>1)
SID_log("Done.",SID_LOG_CLOSE);
}
SID_Allreduce(SID_IN_PLACE,n_all_keep,N_GADGET_TYPE,SID_LONG_LONG,SID_SUM,SID.COMM_WORLD);
SID_log("Done.",SID_LOG_CLOSE);
SID_log("Header properties will be...",SID_LOG_OPEN);
for(i_type=0;i_type<N_GADGET_TYPE;i_type++){
n_all_high_word[i_type]=(unsigned int)(((long long)n_all_keep[i_type])>>32);
n_all[i_type] =(unsigned int)(((long long)n_all_keep[i_type])-(((long long)(n_all_high_word[i_type]))<<32));
n_all_init[i_type] =((long long)(header.n_all_lo_word[i_type]))+(((long long)(header.n_all_hi_word[i_type]))<<32);
if(n_all_keep[i_type]>0)
mass_array[i_type]=header.mass_array[i_type]*((double)n_all_init[i_type]/(double)n_all_keep[i_type]);
else
mass_array[i_type]=0.;
}
for(i_type=0;i_type<N_GADGET_TYPE;i_type++)
SID_log("mass_array[%d]=%le (was %le)", SID_LOG_COMMENT,i_type,mass_array[i_type],header.mass_array[i_type]);
for(i_type=0;i_type<N_GADGET_TYPE;i_type++)
SID_log("n_all[%d] =%d (was %d)",SID_LOG_COMMENT,i_type,n_all[i_type],header.n_all_lo_word[i_type]);
for(i_type=0;i_type<N_GADGET_TYPE;i_type++)
SID_log("high_word[%d] =%d (was %d)",SID_LOG_COMMENT,i_type,n_all_high_word[i_type],header.n_all_hi_word[i_type]);
SID_log("Done.",SID_LOG_CLOSE);
SID_log("Writing subsampled snapshot...",SID_LOG_OPEN|SID_LOG_TIMER);
for(i_file=SID.My_rank,j_file=0;j_file<n_files;i_file+=SID.n_proc,j_file+=SID.n_proc){
if(n_files>1)
SID_log("Processing file(s) %d->%d...",SID_LOG_OPEN,j_file,MIN(j_file+SID.n_proc-1,n_files-1));
if(i_file<n_files){
set_gadget_filename(&fp_gadget,i_file,filename_in);
change_gadget_filename(filename_in_root,"snapshot_subsample",i_snap,i_file,flag_multifile,flag_file_type,filename_out);
if(i_file==0){
FILE *fp_test;
char filename_out_directory[MAX_FILENAME_LENGTH];
strcpy(filename_out_directory,filename_out);
strip_file_root(filename_out_directory);
if((fp_test=fopen(filename_out_directory,"r"))==NULL)
mkdir(filename_out_directory,02755);
else
fclose(fp_test);
}
fp =fopen(filename_in, "r");
fp_out=fopen(filename_out,"w");
// Header
fread_verify(&record_length_in,sizeof(int),1,fp);
fread_verify(&header,sizeof(gadget_header_info),1,fp);
fread_verify(&record_length_out,sizeof(int),1,fp);
for(i_type=0;i_type<N_GADGET_TYPE;i_type++){
n_local[i_type] =header.n_file[i_type];
header.n_file[i_type] =0;
header.mass_array[i_type] =mass_array[i_type];
header.n_all_lo_word[i_type] =n_all[i_type];
header.n_all_hi_word[i_type] =n_all_high_word[i_type];
}
seed=seed_init+1387*i_file;
init_RNG(&seed,&RNG,RNG_DEFAULT);
for(i_type=0,n_keep_total=0,n_init_total=0;i_type<N_GADGET_TYPE;i_type++){
for(j_particle=0;j_particle<n_local[i_type];j_particle++,i_particle++){
if(random_number(&RNG)<=RNG_max){
header.n_file[i_type]++;
n_keep_total++;
}
n_init_total++;
}
}
free_RNG(&RNG);
record_length=record_length_in;
fwrite(&record_length,sizeof(int),1,fp_out);
fwrite(&header,sizeof(gadget_header_info),1,fp_out);
fwrite(&record_length,sizeof(int),1,fp_out);
// Positions
record_length=3*sizeof(GBPREAL)*n_keep_total;
seed=seed_init+1387*i_file;
init_RNG(&seed,&RNG,RNG_DEFAULT);
fread_verify(&record_length_in,sizeof(int),1,fp);
fwrite(&record_length,sizeof(int),1,fp_out);
for(i_type=0;i_type<N_GADGET_TYPE;i_type++){
for(j_particle=0;j_particle<n_local[i_type];j_particle++){
fread_verify(position,sizeof(GBPREAL),3,fp);
if(random_number(&RNG)<=RNG_max)
fwrite(position,sizeof(GBPREAL),3,fp_out);
}
}
fread_verify(&record_length_out,sizeof(int),1,fp);
fwrite(&record_length,sizeof(int),1,fp_out);
free_RNG(&RNG);
// Velocities
record_length=3*sizeof(GBPREAL)*n_keep_total;
seed=seed_init+1387*i_file;
init_RNG(&seed,&RNG,RNG_DEFAULT);
fread_verify(&record_length_in,sizeof(int),1,fp);
fwrite(&record_length,sizeof(int),1,fp_out);
for(i_type=0;i_type<N_GADGET_TYPE;i_type++){
for(j_particle=0;j_particle<n_local[i_type];j_particle++){
fread_verify(velocity,sizeof(GBPREAL),3,fp);
if(random_number(&RNG)<=RNG_max)
fwrite(velocity,sizeof(GBPREAL),3,fp_out);
}
}
fread_verify(&record_length_out,sizeof(int),1,fp);
fwrite(&record_length,sizeof(int),1,fp_out);
free_RNG(&RNG);
// IDs
seed=seed_init+1387*i_file;
init_RNG(&seed,&RNG,RNG_DEFAULT);
fread_verify(&record_length_in,sizeof(int),1,fp);
if(record_length_in/sizeof(int)==n_init_total){
flag_long_ids=FALSE;
record_length=n_keep_total*sizeof(int);
}
else{
flag_long_ids=TRUE;
record_length=n_keep_total*sizeof(long long);
}
fwrite(&record_length,sizeof(int),1,fp_out);
if(flag_long_ids){
for(i_type=0;i_type<N_GADGET_TYPE;i_type++){
for(j_particle=0;j_particle<n_local[i_type];j_particle++){
fread_verify(&id_in_long,sizeof(long long),1,fp);
if(random_number(&RNG)<=RNG_max)
fwrite(&id_in_long,sizeof(long long),1,fp_out);
}
}
}
else{
for(i_type=0;i_type<N_GADGET_TYPE;i_type++){
for(j_particle=0;j_particle<n_local[i_type];j_particle++){
fread_verify(&id_in_int,sizeof(int),1,fp);
if(random_number(&RNG)<=RNG_max)
fwrite(&id_in_int,sizeof(int),1,fp_out);
}
}
}
fread_verify(&record_length_out,sizeof(int),1,fp);
fwrite(&record_length,sizeof(int),1,fp_out);
free_RNG(&RNG);
fclose(fp);
fclose(fp_out);
}
if(n_files>1)
SID_log("Done.",SID_LOG_CLOSE);
}
SID_log("Done.",SID_LOG_CLOSE);
}
int main(int argc, char *argv[]){
int n_search;
int i_halo;
char filename_SSimPL_root[MAX_FILENAME_LENGTH];
char filename_in[MAX_FILENAME_LENGTH];
char group_text_prefix[4];
int n_files;
int k_read;
int max_n_groups;
int l_read;
int n_groups;
int j_read;
int mode;
int n_groups_i;
int n_groups_j;
int j_halo;
int match;
int i_read;
int i_read_start;
int i_read_stop;
SID_fp fp_in;
SID_init(&argc,&argv,NULL,NULL);
SID_log("Writing match score table...",SID_LOG_OPEN);
FILE *fp=stdout;
fprintf(fp,"# Table of match score values.\n");
fprintf(fp,"# Match Rank Index=\n",MATCH_SCORE_RANK_INDEX);
fprintf(fp,"# Column (01): n_particles\n");
fprintf(fp,"# (02): max score (n_particles)\n");
fprintf(fp,"# (03): min match score (n_particles)\n");
fprintf(fp,"# (04): max score (0.90*n_particles)\n");
fprintf(fp,"# (05): max score (0.80*n_particles)\n");
fprintf(fp,"# (06): max score (0.70*n_particles)\n");
fprintf(fp,"# (07): max score (0.60*n_particles)\n");
fprintf(fp,"# (08): max score (0.50*n_particles)\n");
fprintf(fp,"# (09): max score (0.40*n_particles)\n");
fprintf(fp,"# (10): max score (0.30*n_particles)\n");
fprintf(fp,"# (11): max score (0.20*n_particles)\n");
fprintf(fp,"# (12): max score (0.10*n_particles)\n");
fprintf(fp,"# (13): max score (0.50*n_particles)\n");
fprintf(fp,"# (14): max score (0.01*n_particles)\n");
for(double n_particles=1.;n_particles<1e9;n_particles*=1.2){
fprintf(fp,"%le %le %le %le %le %le %le %le %le %le %le %le %le %le\n",
n_particles,
maximum_match_score(n_particles),
minimum_match_score(n_particles),
maximum_match_score(0.9*n_particles),
maximum_match_score(0.8*n_particles),
maximum_match_score(0.7*n_particles),
maximum_match_score(0.6*n_particles),
maximum_match_score(0.5*n_particles),
maximum_match_score(0.4*n_particles),
maximum_match_score(0.3*n_particles),
maximum_match_score(0.2*n_particles),
maximum_match_score(0.1*n_particles),
maximum_match_score(0.05*n_particles),
maximum_match_score(0.01*n_particles));
}
if(fp!=stdout && fp!=stderr)
fclose(fp);
SID_log("Done.",SID_LOG_CLOSE);
SID_exit(ERROR_NONE);
}
int main(int argc, char *argv[]){
plist_info plist;
char filename_groups_root[256];
char filename_snapshot_root[256];
char filename_snapshot[256];
char filename_number[256];
char filename_output_properties[256];
char filename_output_properties_dir[256];
char filename_output_profiles[256];
char filename_output_profiles_dir[256];
char filename_output_properties_temp[256];
char filename_output_profiles_temp[256];
char filename_input_properties[256];
char filename_input_properties_dir[256];
char filename_input_profiles[256];
char filename_input_profiles_dir[256];
char filename_input_properties_temp[256];
char filename_input_profiles_temp[256];
char group_text_prefix[4];
int n_groups_process;
int n_groups;
int n_groups_all;
int j_file;
int j_file_in;
int i_group;
int i_file_lo;
int i_file_hi;
int i_file;
int i_file_skip;
int i_particle;
int j_particle;
int i_process;
int n_particles;
int n_particles_max;
GBPREAL *x_array;
GBPREAL *y_array;
GBPREAL *z_array;
GBPREAL *vx_array;
GBPREAL *vy_array;
GBPREAL *vz_array;
int *n_particles_groups_process;
int *n_particles_groups;
int *n_particles_subgroups;
int *group_offset;
size_t n_particles_in_groups;
size_t *ids_snapshot;
size_t *ids_groups;
size_t *ids_sort_index;
size_t *ids_snapshot_sort_index;
size_t *ids_groups_sort_index;
size_t n_particles_snapshot;
int i_value;
double h_Hubble;
double Omega_M;
double Omega_b;
double Omega_Lambda;
double f_gas;
double Omega_k;
double sigma_8;
double n_spec;
double redshift;
double box_size;
double particle_mass;
int r_val;
struct stat file_stats;
size_t n_bytes;
size_t n_bytes_buffer;
void *buffer;
FILE *fp_properties;
FILE *fp_profiles;
FILE *fp_properties_temp;
FILE *fp_profiles_temp;
cosmo_info *cosmo;
halo_properties_info properties;
halo_profile_info profile;
int n_files,n_files_i;
int n_files_temp=1;
int flag_process_profiles;
SID_init(&argc,&argv,NULL,NULL);
// Fetch user inputs
strcpy(filename_groups_root,argv[1]);
i_file_lo =atoi(argv[2]);
i_file_hi =atoi(argv[3]);
i_file_skip=atoi(argv[4]);
flag_process_profiles=FALSE;
SID_log("Processing group/subgroup statistics for files #%d->#%d...",SID_LOG_OPEN|SID_LOG_TIMER,i_file_lo,i_file_hi);
for(i_file=i_file_lo;i_file<=i_file_hi;i_file+=i_file_skip){
sprintf(filename_number,"%03d", i_file);
SID_log("Processing file #%d...",SID_LOG_OPEN|SID_LOG_TIMER,i_file);
for(i_process=0;i_process<2;i_process++){
switch(i_process){
case 0:
sprintf(group_text_prefix,"");
break;
case 1:
sprintf(group_text_prefix,"sub");
break;
}
SID_log("Processing %sgroup files...",SID_LOG_OPEN|SID_LOG_TIMER,group_text_prefix);
char filename_base[MAX_FILENAME_LENGTH];
sprintf(filename_base,"%s_%03d",filename_groups_root,i_file);
strip_path(filename_base);
sprintf(filename_input_properties, "%s_%s.catalog_%sgroups_properties", filename_groups_root,filename_number,group_text_prefix);
sprintf(filename_output_properties, "%s_cat_%s.catalog_%sgroups_properties",filename_groups_root,filename_number,group_text_prefix);
sprintf(filename_input_properties_dir, "%s",filename_input_properties);
sprintf(filename_output_properties_dir,"%s",filename_output_properties);
if(flag_process_profiles){
sprintf(filename_input_profiles, "%s_%s.catalog_%sgroups_profiles", filename_groups_root,filename_number,group_text_prefix);
sprintf(filename_output_profiles, "%s_cat_%s.catalog_%sgroups_profiles",filename_groups_root,filename_number,group_text_prefix);
sprintf(filename_input_profiles_dir, "%s",filename_input_profiles);
sprintf(filename_output_profiles_dir,"%s",filename_output_profiles);
}
// Get the number of files involved
j_file=0;
sprintf(filename_input_properties_temp,"%s/%s.catalog_%sgroups_properties.%d",filename_input_properties_dir,filename_base,group_text_prefix,j_file);
if((fp_properties_temp=fopen(filename_input_properties_temp,"r"))==NULL)
SID_trap_error("Can not open {%s}",ERROR_IO_OPEN,filename_output_properties_temp);
fread(&j_file, sizeof(int),1,fp_properties_temp);
fread(&n_files, sizeof(int),1,fp_properties_temp);
fclose(fp_properties_temp);
// Concatinate the temporary files together
fp_properties=fopen(filename_output_properties,"w");
if(flag_process_profiles)
fp_profiles =fopen(filename_output_profiles, "w");
for(j_file=0;j_file<n_files;j_file++){
SID_log("Processing file No. %d of %d...",SID_LOG_OPEN,j_file+1,n_files);
// Set filenames
sprintf(filename_input_properties_temp,"%s/%s.catalog_%sgroups_properties.%d",filename_input_properties_dir,filename_base,group_text_prefix,j_file);
sprintf(filename_input_profiles_temp, "%s/%s.catalog_%sgroups_profiles.%d", filename_input_properties_dir,filename_base,group_text_prefix,j_file);
// Cat properties
if((fp_properties_temp=fopen(filename_input_properties_temp,"r"))==NULL)
SID_trap_error("Can't open file {%s}",ERROR_IO_OPEN,filename_output_properties_temp);
fread(&j_file_in, sizeof(int),1,fp_properties_temp);
fread(&n_files_i, sizeof(int),1,fp_properties_temp);
fread(&n_groups, sizeof(int),1,fp_properties_temp);
fread(&n_groups_all,sizeof(int),1,fp_properties_temp);
SID_log("Processing properties (%d of %d %sgroups)...",SID_LOG_OPEN,n_groups,n_groups_all,group_text_prefix);
if(j_file==0){
fwrite(&j_file, sizeof(int),1,fp_properties);
fwrite(&n_files_temp,sizeof(int),1,fp_properties);
fwrite(&n_groups_all,sizeof(int),1,fp_properties);
fwrite(&n_groups_all,sizeof(int),1,fp_properties);
}
for(i_group=0;i_group<n_groups;i_group++){
fread( &properties,sizeof(halo_properties_info),1,fp_properties_temp);
fwrite(&properties,sizeof(halo_properties_info),1,fp_properties);
}
fclose(fp_properties_temp);
SID_log("Done.",SID_LOG_CLOSE);
// Cat profiles
if(flag_process_profiles){
fp_profiles_temp=fopen(filename_output_profiles_temp,"r");
fread(&j_file_in, sizeof(int),1,fp_profiles_temp);
fread(&n_files_i, sizeof(int),1,fp_profiles_temp);
fread(&n_groups, sizeof(int),1,fp_profiles_temp);
fread(&n_groups_all,sizeof(int),1,fp_profiles_temp);
SID_log("Processing profiles (%d of %d %sgroups)...",SID_LOG_OPEN,n_groups,n_groups_all,group_text_prefix);
if(j_file==0){
fwrite(&j_file, sizeof(int),1,fp_profiles);
fwrite(&n_files_temp,sizeof(int),1,fp_profiles);
fwrite(&n_groups_all,sizeof(int),1,fp_profiles);
fwrite(&n_groups_all,sizeof(int),1,fp_profiles);
}
for(i_group=0;i_group<n_groups;i_group++){
fread( &(profile.n_bins),sizeof(int),1,fp_profiles_temp);
fwrite(&(profile.n_bins),sizeof(int),1,fp_profiles);
if(profile.n_bins>0){
fread( profile.bins,sizeof(halo_profile_bin_info),profile.n_bins,fp_profiles_temp);
fwrite(profile.bins,sizeof(halo_profile_bin_info),profile.n_bins,fp_profiles);
}
}
fclose(fp_profiles_temp);
SID_log("Done.",SID_LOG_CLOSE);
}
SID_log("Done. (file %3d of %3d)",SID_LOG_CLOSE,j_file,n_files);
}
fclose(fp_properties);
if(flag_process_profiles)
fclose(fp_profiles);
SID_log("Done.",SID_LOG_CLOSE);
}
SID_log("Done.",SID_LOG_CLOSE);
}
SID_log("Done.",SID_LOG_CLOSE);
SID_exit(ERROR_NONE);
}
int main(int argc, char *argv[]){
SID_init(&argc,&argv,NULL,NULL);
// Parse arguments and initialize
double z;
if(argc<2 || argc>3){
fprintf(stderr,"\n Syntax: %s z [gbpCosmo_file.txt]\n",argv[0]);
fprintf(stderr," ------\n\n");
return(ERROR_SYNTAX);
}
else
z=(double)atof(argv[1]);
SID_log("Computing clustering information for z=%.2lf...",SID_LOG_OPEN,z);
// Initialize cosmology
cosmo_info *cosmo=NULL;
if(argc==2)
init_cosmo_default(&cosmo);
else if(argc==3)
read_gbpCosmo_file(&cosmo,argv[2]);
// Initialize
int mode =PSPEC_LINEAR_TF;
int component=PSPEC_ALL_MATTER;
init_sigma_M(&cosmo,z,mode,component);
int n_k =((int *)ADaPS_fetch(cosmo,"n_k"))[0];
double *lk_P = (double *)ADaPS_fetch(cosmo,"lk_P");
double h_Hubble=((double *)ADaPS_fetch(cosmo,"h_Hubble"))[0];
SID_log("Done.",SID_LOG_CLOSE);
// Generate file
SID_log("Writing table to stdout...",SID_LOG_OPEN);
double delta_c =1.686;
double m_per_mpc_h=M_PER_MPC/h_Hubble;
printf("# Column (01): k [h Mpc^-1]\n");
printf("# (02): R [h^-1 Mpc] \n");
printf("# (03): M [h^-1 M_sol]\n");
printf("# (04): V_max [km/s] \n");
printf("# (05): P_k [(h^-1 Mpc)^3]\n");
printf("# (06): sigma\n");
printf("# (07): nu (peak height)\n");
printf("# (08): b_BPR\n");
printf("# (09): b_TRK\n");
printf("# (10): z-space boost Kaiser '87 (applied to b_TRK)\n");
printf("# (11): b_TRK total (w/ Kaiser boost)\n");
printf("# (12): b_halo_Poole \n");
printf("# (13): z-space boost Poole \n");
printf("# (14): b_total_Poole \n");
printf("# (15): b_halo_Poole (substructure)\n");
printf("# (16): z-space boost Poole (substructure)\n");
printf("# (17): b_total_Poole (substructure)\n");
for(int i_k=0;i_k<n_k;i_k++){
double k_P =take_alog10(lk_P[i_k]);
double R_P =R_of_k(k_P);
double M_R =M_of_k(k_P,z,cosmo);
double P_k =power_spectrum(k_P,z,&cosmo,mode,component);
double sigma=sqrt(power_spectrum_variance(k_P,z,&cosmo,mode,component));
double V_max=V_max_NFW(M_R,z,NFW_MODE_DEFAULT,&cosmo);
double nu =delta_c/sigma;
double bias =1.;
if(M_R<1e16*M_SOL){
printf("%10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le\n",
k_P*m_per_mpc_h,
R_P/m_per_mpc_h,
M_R/(M_SOL/h_Hubble),
V_max*1e-3,
P_k/pow(m_per_mpc_h,3.),
sigma,
nu,
bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_BPR),
bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_TRK),
bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_TRK|BIAS_MODEL_KAISER_BOOST),
bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_TRK|BIAS_MODEL_KAISER),
bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_POOLE_HALO),
bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_POOLE_ZSPACE),
bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_POOLE_TOTAL),
bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_POOLE_SUBSTRUCTURE|BIAS_MODEL_POOLE_HALO),
bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_POOLE_SUBSTRUCTURE|BIAS_MODEL_POOLE_ZSPACE),
bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_POOLE_SUBSTRUCTURE|BIAS_MODEL_POOLE_TOTAL));
}
}
SID_log("Done.",SID_LOG_CLOSE);
// Clean-up
free_cosmo(&cosmo);
SID_log("Done.",SID_LOG_CLOSE);
SID_exit(ERROR_NONE);
}
int main(int argc, char *argv[]){
char filename_tree_in[256];
int select_tree;
int n_trees;
int n_halos_total;
int *n_halos;
int i_tree;
FILE *fp;
halo_properties_SAGE_info *halos;
halo_properties_SAGE_info halo;
int *snap_num;
size_t *snap_num_index;
int i_snap,i_halo,j_halo,k_halo;
int n_halos_snap;
int *group_halo_first;
int group_halo_last;
size_t *group_halo_first_index;
int *snap_index;
int descendant_min,descendant_max;
int progenitor_first_min,progenitor_first_max;
int progenitor_next_min,progenitor_next_max;
int group_halo_first_min,group_halo_first_max;
int group_halo_next_min,group_halo_next_max;
int snap_num_min,snap_num_max;
int halo_index_min,halo_index_max;
int n_gal=0;
int max_snap=0;
SID_init(&argc,&argv,NULL,NULL);
// Fetch user inputs
strcpy(filename_tree_in,argv[1]);
select_tree=atoi(argv[2]);
SID_log("Displaying tree %d from {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,select_tree,filename_tree_in);
fp=fopen(filename_tree_in,"r");
fread_verify(&n_trees, sizeof(int),1,fp);
fread_verify(&n_halos_total,sizeof(int),1,fp);
SID_log("(%d trees and %d halos)...",SID_LOG_CONTINUE,n_trees,n_halos_total);
n_halos=(int *)SID_malloc(sizeof(int)*n_trees);
fread_verify(n_halos,sizeof(int),n_trees,fp);
for(i_tree=0;i_tree<select_tree;i_tree++){
for(i_halo=0;i_halo<n_halos[i_tree];i_halo++){
fread_verify(&halo,sizeof(halo_properties_SAGE_info),1,fp);
max_snap=MAX(max_snap,halo.snap_num);
}
}
halos =(halo_properties_SAGE_info *)SID_malloc(sizeof(halo_properties_SAGE_info)*n_halos[i_tree]);
snap_num =(int *)SID_malloc(sizeof(int)*n_halos[i_tree]);
snap_index =(int *)SID_malloc(sizeof(int)*n_halos[i_tree]);
group_halo_first =(int *)SID_malloc(sizeof(int)*n_halos[i_tree]);
fread_verify(halos,sizeof(halo_properties_SAGE_info),n_halos[i_tree],fp);
descendant_min =10000;
descendant_max = 0;
progenitor_first_min=10000;
progenitor_first_max= 0;
progenitor_next_min =10000;
progenitor_next_max = 0;
group_halo_first_min=10000;
group_halo_first_max= 0;
group_halo_next_min =10000;
group_halo_next_max = 0;
snap_num_min =10000;
snap_num_max = 0;
halo_index_min =10000;
halo_index_max = 0;
for(i_halo=0;i_halo<n_halos[i_tree];i_halo++){
snap_num[i_halo] =halos[i_halo].snap_num;
if(halos[i_halo].descendant>=0)
descendant_min =MIN(descendant_min,halos[i_halo].descendant);
if(halos[i_halo].progenitor_first>=0)
progenitor_first_min=MIN(progenitor_first_min,halos[i_halo].progenitor_first);
if(halos[i_halo].progenitor_next>=0)
progenitor_next_min =MIN(progenitor_next_min,halos[i_halo].progenitor_next);
if(halos[i_halo].group_halo_first>=0)
group_halo_first_min=MIN(group_halo_first_min,halos[i_halo].group_halo_first);
if(halos[i_halo].group_halo_next>=0)
group_halo_next_min =MIN(group_halo_next_min,halos[i_halo].group_halo_next);
if(halo.snap_num>=0)
snap_num_min =MIN(snap_num_min,halos[i_halo].snap_num);
if(halos[i_halo].halo_index>=0)
halo_index_min =MIN(halo_index_min,halos[i_halo].halo_index);
descendant_max =MAX(descendant_max,halos[i_halo].descendant);
progenitor_first_max=MAX(progenitor_first_max,halos[i_halo].progenitor_first);
progenitor_next_max =MAX(progenitor_next_max,halos[i_halo].progenitor_next);
group_halo_first_max=MAX(group_halo_first_max,halos[i_halo].group_halo_first);
group_halo_next_max =MAX(group_halo_next_max,halos[i_halo].group_halo_next);
snap_num_max =MAX(snap_num_max,halos[i_halo].snap_num);
halo_index_max =MAX(halo_index_max,halos[i_halo].halo_index);
max_snap=MAX(max_snap,halos[i_halo].snap_num);
}
i_tree++;
for(;i_tree<n_trees;i_tree++){
for(i_halo=0;i_halo<n_halos[i_tree];i_halo++){
fread_verify(&halo,sizeof(halo_properties_SAGE_info),1,fp);
max_snap=MAX(max_snap,halo.snap_num);
}
}
rewind(fp);
fread_verify(&n_trees, sizeof(int),1,fp);
fread_verify(&n_halos_total,sizeof(int),1,fp);
for(i_tree=0,n_gal=0;i_tree<n_trees;i_tree++){
for(i_halo=0;i_halo<n_halos[i_tree];i_halo++){
fread_verify(&halo,sizeof(halo_properties_SAGE_info),1,fp);
if(halo.snap_num==max_snap) n_gal++;
}
}
SID_log("n_trees =%d", SID_LOG_COMMENT,n_trees);
SID_log("n_halos[snap=%3d]=%d", SID_LOG_COMMENT,n_gal);
SID_log("n_halos_total =%d", SID_LOG_COMMENT,n_halos_total);
SID_log("Descendants =%d->%d",SID_LOG_COMMENT,descendant_min, descendant_max);
SID_log("Progenitor_first =%d->%d",SID_LOG_COMMENT,progenitor_first_min,progenitor_first_max);
SID_log("Progenitor_next =%d->%d",SID_LOG_COMMENT,progenitor_next_min, progenitor_next_max);
SID_log("Group_halo_first =%d->%d",SID_LOG_COMMENT,group_halo_first_min,group_halo_first_max);
SID_log("Group_halo_next =%d->%d",SID_LOG_COMMENT,group_halo_next_min, group_halo_next_max);
SID_log("Snap_num =%d->%d",SID_LOG_COMMENT,snap_num_min, snap_num_max);
SID_log("Halo_index =%d->%d",SID_LOG_COMMENT,halo_index_min, halo_index_max);
merge_sort((void *)snap_num,(size_t)n_halos[i_tree],&snap_num_index,SID_INT,SORT_COMPUTE_INDEX,FALSE);
for(i_snap=snap_num_max,i_halo=n_halos[i_tree]-1;i_snap>=snap_num_min && i_halo>=0;i_snap--){
n_halos_snap=0;
while(snap_num[snap_num_index[i_halo]]==i_snap && i_halo>0){
n_halos_snap++;
i_halo--;
}
if(snap_num[snap_num_index[i_halo]]==i_snap){
n_halos_snap++;
i_halo--;
}
for(j_halo=0;j_halo<n_halos_snap;j_halo++){
group_halo_first[j_halo]=halos[snap_num_index[i_halo+j_halo+1]].group_halo_first;
snap_index[j_halo] =snap_num_index[i_halo+j_halo+1];
}
merge_sort((void *)group_halo_first,(size_t)n_halos_snap,&group_halo_first_index,SID_INT,SORT_COMPUTE_INDEX,FALSE);
group_halo_last=-99;
if(n_halos_snap>0)
printf("Snap #%3d: ",i_snap);
for(j_halo=0;j_halo<n_halos_snap;j_halo++){
k_halo=snap_index[group_halo_first_index[j_halo]];
if(group_halo_last!=halos[k_halo].group_halo_first){
if(j_halo!=0)
printf(") ");
printf("(");
}
else
printf(" ");
// Generate output
/*
printf("I:%5d->%5d/S:%5d/PF:%5d/PN:%5d/G:%5d->%5d",
k_halo,
halos[k_halo].descendant,
halos[k_halo].n_particles,
halos[k_halo].progenitor_first,
halos[k_halo].progenitor_next,
halos[k_halo].group_halo_first,
halos[k_halo].group_halo_next);
*/
/*
printf("I%05d.D%05d.S%05d.F%05d.N%05d.f%05d.n%05d",
k_halo,
halos[k_halo].descendant,
halos[k_halo].n_particles,
halos[k_halo].progenitor_first,
halos[k_halo].progenitor_next,
halos[k_halo].group_halo_first,
halos[k_halo].group_halo_next);
*/
/*
printf("%05d",
halos[k_halo].n_particles);
*/
/*
printf("%05d/%05d/%05d",
k_halo,halos[k_halo].descendant,
halos[k_halo].n_particles);
*/
printf("%05d/%05d/%05d/%05d",
k_halo,
halos[k_halo].descendant,
halos[k_halo].group_halo_first,
halos[k_halo].group_halo_next);
group_halo_last=halos[k_halo].group_halo_first;
}
if(n_halos_snap>0)
printf(")\n");
SID_free((void **)&group_halo_first_index);
}
SID_free((void **)&snap_num_index);
SID_free((void **)&snap_num);
SID_free((void **)&snap_index);
SID_free((void **)&group_halo_first);
SID_free((void **)&n_halos);
SID_free((void **)&halos);
fclose(fp);
SID_log("Done.",SID_LOG_CLOSE);
SID_exit(0);
}
int main(int argc, char *argv[]){
char filename_tree_in[256];
int n_trees;
int n_halos_total;
int *n_halos;
int i_tree;
FILE *fp;
halo_properties_SAGE_info *halos;
halo_properties_SAGE_info halo;
int *snap_num;
size_t *snap_num_index;
int i_snap,i_halo,j_halo,k_halo;
int n_halos_snap;
int *group_halo_first;
int group_halo_last;
size_t *group_halo_first_index;
int *snap_index;
int descendant_min,descendant_max;
int progenitor_first_min,progenitor_first_max;
int progenitor_next_min,progenitor_next_max;
int group_halo_first_min,group_halo_first_max;
int group_halo_next_min,group_halo_next_max;
int snap_num_min,snap_num_max;
int halo_index_min,halo_index_max;
int n_gal=0;
int max_snap=0;
int n_halos_max;
int n_subtrees;
int halo_search;
int flag_search;
SID_init(&argc,&argv,NULL,NULL);
// Fetch user inputs
strcpy(filename_tree_in,argv[1]);
halo_search=atoi(argv[2]);
SID_log("Finding halo #%d's tree in {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,halo_search,filename_tree_in);
fp=fopen(filename_tree_in,"r");
fread_verify(&n_trees, sizeof(int),1,fp);
fread_verify(&n_halos_total,sizeof(int),1,fp);
SID_log("%d trees and %d halos",SID_LOG_COMMENT,n_trees,n_halos_total);
n_halos=(int *)SID_malloc(sizeof(int)*n_trees);
fread_verify(n_halos,sizeof(int),n_trees,fp);
calc_max(n_halos,&n_halos_max,n_trees,SID_INT,CALC_MODE_DEFAULT);
halos =(halo_properties_SAGE_info *)SID_malloc(sizeof(halo_properties_SAGE_info)*n_halos_max);
for(i_tree=0,flag_search=TRUE;i_tree<n_trees && flag_search;i_tree++){
fread_verify(halos,sizeof(halo_properties_SAGE_info),n_halos[i_tree],fp);
for(i_halo=0,n_subtrees=0;i_halo<n_halos[i_tree];i_halo++){
if(halos[i_halo].halo_id==halo_search){
flag_search=FALSE;
SID_log("Found it in tree #%d",SID_LOG_COMMENT,i_tree);
}
}
}
if(flag_search)
SID_log("COULD NOT FIND HALO #%d IN THIS FILE!",SID_LOG_COMMENT,halo_search);
// Clean-up
fclose(fp);
SID_free((void **)&halos);
SID_log("Done.",SID_LOG_CLOSE);
SID_exit(0);
}
int main(int argc, char *argv[]){
char filename_properties[256];
char filename_profiles[256];
char filename_out_root[256];
char filename_out[256];
char filename_SSimPL[MAX_FILENAME_LENGTH];
char filename_halo_type[MAX_FILENAME_LENGTH];
int snap_number;
int snap_number_start;
int snap_number_stop;
int snap_number_step;
SID_init(&argc,&argv,NULL,NULL);
strcpy(filename_SSimPL, argv[1]);
strcpy(filename_halo_type,argv[2]);
snap_number_start =atoi(argv[3]);
snap_number_stop =atoi(argv[4]);
snap_number_step =atoi(argv[5]);
strcpy(filename_out_root, argv[6]);
int flag_use_profiles=FALSE;
if(SID.I_am_Master){
SID_log("Processing catalogs for snaps %d->%d...",SID_LOG_OPEN|SID_LOG_TIMER,snap_number_start,snap_number_stop);
for(snap_number=snap_number_start;snap_number<=snap_number_stop;snap_number++){
// Open halos
char filename_halos[256];
sprintf(filename_halos,"%s/halos/%s_%03d.catalog_groups",filename_SSimPL,filename_halo_type,snap_number);
FILE *fp_halos=NULL;
if((fp_halos=fopen(filename_halos,"r"))==NULL)
SID_trap_error("Could not open halo file {%s} for reading.",ERROR_IO_OPEN,filename_halos);
int n_groups_halos,group_offset_byte_size;
fread_verify(&n_groups_halos, sizeof(int),1,fp_halos);
fread_verify(&group_offset_byte_size,sizeof(int),1,fp_halos);
// Skip group sizes and offsets
fseeko(fp_halos,(off_t)(n_groups_halos*(sizeof(int)+group_offset_byte_size)),SEEK_CUR);
// Open catalogs
char filename_cat_root[256];
sprintf(filename_cat_root,"%s/catalogs/%s",filename_SSimPL,filename_halo_type);
fp_catalog_info fp_catalog_groups;
fp_catalog_info fp_catalog_subgroups;
fopen_catalog(filename_cat_root,
snap_number,
READ_CATALOG_GROUPS|READ_CATALOG_PROPERTIES|READ_CATALOG_PROPERTIES,
&fp_catalog_groups);
fopen_catalog(filename_cat_root,
snap_number,
READ_CATALOG_SUBGROUPS|READ_CATALOG_PROPERTIES|READ_CATALOG_PROPERTIES,
&fp_catalog_subgroups);
// Open SO files if they're available
fp_multifile_info fp_SO;
int flag_use_SO=fopen_multifile("%s/catalogs/%s_%03d.catalog_groups_SO",sizeof(float),&fp_SO,filename_SSimPL,filename_halo_type,snap_number);
if(flag_use_SO)
SID_log("SO files present.",SID_LOG_COMMENT);
// Sanity check
if(n_groups_halos!=fp_catalog_groups.n_halos_total)
SID_trap_error("Group counts in halo and catalog files don't match (ie. %d!=%d).",ERROR_LOGIC,n_groups_halos,fp_catalog_groups.n_halos_total);
// Process halos
SID_log("Processing snapshot #%03d...",SID_LOG_OPEN,snap_number);
SID_log("(%d groups, %d subgroups)...",SID_LOG_CONTINUE,fp_catalog_groups.n_halos_total,fp_catalog_subgroups.n_halos_total);
// Initialzie halo trend data structure
halo_trend_info halo_trend_data;
char filename_run[MAX_FILENAME_LENGTH];
sprintf(filename_run,"%s/run/run.txt",filename_SSimPL);
parameter_list_info *parameter_list=NULL;
init_parameter_list(¶meter_list);
add_parameter_to_list(parameter_list,"box_size",SID_DOUBLE, PARAMETER_MODE_DEFAULT);
add_parameter_to_list(parameter_list,"N_dark", SID_SIZE_T, PARAMETER_MODE_DEFAULT);
add_parameter_to_list(parameter_list,"m_dark", SID_DOUBLE, PARAMETER_MODE_DEFAULT);
read_gbpParam_file(filename_run,parameter_list);
fetch_parameter_data(parameter_list,"box_size",&(halo_trend_data.box_size));
fetch_parameter_data(parameter_list,"m_dark", &(halo_trend_data.m_p));
free_parameter_list(¶meter_list);
char filename_snaps[MAX_FILENAME_LENGTH];
sprintf(filename_snaps,"%s/run/a_list.txt",filename_SSimPL);
FILE *fp_snaps=fopen(filename_snaps,"r");
size_t line_length=0;
char *line=NULL;
halo_trend_data.n_snaps=count_lines_data(fp_snaps);
halo_trend_data.z_list =(double *)SID_malloc(sizeof(double)*halo_trend_data.n_snaps);
for (int i_snap=0;i_snap<halo_trend_data.n_snaps;i_snap++){
double a_i;
grab_next_line_data(fp_snaps,&line,&line_length);
grab_double(line,1,&a_i);
halo_trend_data.z_list[i_snap]=z_of_a(a_i);
}
SID_free(SID_FARG line);
fclose(fp_snaps);
// Initialize halo data structure
halo_info halo_data;
halo_data.flag_use_profiles = flag_use_profiles;
halo_data.flag_use_SO = flag_use_SO;
halo_data.snapshot = snap_number;
halo_data.properties_group =(halo_properties_info *)SID_malloc(sizeof(halo_properties_info));
halo_data.properties_subgroup=(halo_properties_info *)SID_malloc(sizeof(halo_properties_info));
halo_data.profiles_group =(halo_profile_info *)SID_malloc(sizeof(halo_profile_info));
halo_data.profiles_subgroup =(halo_profile_info *)SID_malloc(sizeof(halo_profile_info));
// Initialize trends
trend_info *trend_M_FoF=NULL;
init_trend(&trend_M_FoF,"SSFctn",&halo_trend_data,init_halo_trend_property_logM_FoF,free_halo_trend_property_logM_FoF,calc_halo_trend_property_index_logM_FoF);
init_halo_trend_coordinate(&halo_trend_data,trend_M_FoF,"SSFctn");
// Read halos and construct histograms
for(int i_group=0,i_subgroup=0;i_group<fp_catalog_groups.n_halos_total;i_group++){
int n_subgroups_group;
// Read group catalog
fread_catalog_file(&fp_catalog_groups,NULL,NULL,halo_data.properties_group,halo_data.profiles_group,i_group);
// Read number of subgroups
fread_verify(&n_subgroups_group,sizeof(int),1,fp_halos);
// Read SO masses (if available)
if(flag_use_SO)
fread_multifile(&fp_SO,halo_data.SO_data_group,i_group);
// Loop over subgroups
halo_data.n_sub =n_subgroups_group;
halo_data.np_sub =0;
halo_data.np_sub_largest=0;
for(int j_subgroup=0;j_subgroup<n_subgroups_group;i_subgroup++,j_subgroup++){
// Read subgroup properties
fread_catalog_file(&fp_catalog_subgroups,NULL,NULL,halo_data.properties_subgroup,halo_data.profiles_subgroup,i_subgroup);
int np_i=halo_data.properties_subgroup->n_particles;
halo_data.np_sub+=np_i;
if(np_i>halo_data.np_sub_largest)
halo_data.np_sub_largest=np_i;
// Add halo to subgroup trends
}
// Add halo to group trends
add_item_to_trend(trend_M_FoF,GBP_ADD_ITEM_TO_TREND_DEFAULT,&halo_data);
}
// Write results
char filename_out[MAX_FILENAME_LENGTH];
sprintf(filename_out,"%s_%03d",filename_out_root,snap_number);
write_trend_ascii(trend_M_FoF,filename_out);
free_trend(&trend_M_FoF);
// Clean-up
SID_free(SID_FARG halo_trend_data.z_list);
SID_free(SID_FARG halo_data.properties_group);
SID_free(SID_FARG halo_data.properties_subgroup);
SID_free(SID_FARG halo_data.profiles_group);
SID_free(SID_FARG halo_data.profiles_subgroup);
fclose(fp_halos);
fclose_catalog(&fp_catalog_groups);
fclose_catalog(&fp_catalog_subgroups);
fclose_multifile(&fp_SO);
SID_log("Done.",SID_LOG_CLOSE);
}
SID_log("Done.",SID_LOG_CLOSE);
}
SID_exit(ERROR_NONE);
}
int main(int argc, char *argv[]){
int n_species;
int n_load;
int n_used;
int flag_used[N_GADGET_TYPE];
char species_name[256];
double h_Hubble;
double n_spec;
double redshift;
int i_species;
char n_string[64];
int n[3];
double L[3];
FILE *fp_1D;
FILE *fp_2D;
cosmo_info *cosmo;
field_info *field[N_GADGET_TYPE];
field_info *field_norm[N_GADGET_TYPE];
plist_info plist_header;
plist_info plist;
FILE *fp;
int i_temp;
int n_temp;
double *k_temp;
double *kmin_temp;
double *kmax_temp;
double *P_temp;
size_t *n_mode_temp;
double *sigma_P_temp;
double *shot_noise_temp;
double *dP_temp;
int snapshot_number;
int i_compute;
int distribution_scheme;
double k_min_1D;
double k_max_1D;
double k_min_2D;
double k_max_2D;
int n_k_1D;
int n_k_2D;
double *k_1D;
double *P_k_1D;
double *dP_k_1D;
int *n_modes_1D;
double *P_k_2D;
double *dP_k_2D;
int *n_modes_2D;
int n_groups=1;
double dk_1D;
double dk_2D;
char *grid_identifier;
// Initialization -- MPI etc.
SID_init(&argc,&argv,NULL,NULL);
// Parse arguments
int grid_size;
char filename_in_root[MAX_FILENAME_LENGTH];
char filename_out_root[MAX_FILENAME_LENGTH];
strcpy(filename_in_root, argv[1]);
snapshot_number=(int)atoi(argv[2]);
strcpy(filename_out_root, argv[3]);
grid_size =(int)atoi(argv[4]);
if(!strcmp(argv[5],"ngp") || !strcmp(argv[5],"NGP"))
distribution_scheme=MAP2GRID_DIST_NGP;
else if(!strcmp(argv[5],"cic") || !strcmp(argv[5],"CIC"))
distribution_scheme=MAP2GRID_DIST_CIC;
else if(!strcmp(argv[5],"tsc") || !strcmp(argv[5],"TSC"))
distribution_scheme=MAP2GRID_DIST_TSC;
else if(!strcmp(argv[5],"d12") || !strcmp(argv[5],"D12"))
distribution_scheme=MAP2GRID_DIST_DWT12;
else if(!strcmp(argv[5],"d20") || !strcmp(argv[5],"D20"))
distribution_scheme=MAP2GRID_DIST_DWT20;
else
SID_trap_error("Invalid distribution scheme {%s} specified.",ERROR_SYNTAX,argv[5]);
SID_log("Smoothing Gadget file {%s;snapshot=#%d} to a %dx%dx%d grid with %s kernel...",SID_LOG_OPEN|SID_LOG_TIMER,
filename_in_root,snapshot_number,grid_size,grid_size,grid_size,argv[5]);
// Initialization -- fetch header info
SID_log("Reading Gadget header...",SID_LOG_OPEN);
gadget_read_info fp_gadget;
int flag_filefound=init_gadget_read(filename_in_root,snapshot_number,&fp_gadget);
int flag_multifile=fp_gadget.flag_multifile;
int flag_file_type=fp_gadget.flag_file_type;
gadget_header_info header =fp_gadget.header;
double box_size =(double)(header.box_size);
size_t *n_all =(size_t *)SID_calloc(sizeof(size_t)*N_GADGET_TYPE);
size_t n_total;
if(flag_filefound){
if(SID.I_am_Master){
FILE *fp_in;
char filename[MAX_FILENAME_LENGTH];
int block_length_open;
int block_length_close;
set_gadget_filename(&fp_gadget,0,filename);
fp_in=fopen(filename,"r");
fread_verify(&block_length_open, sizeof(int),1,fp_in);
fread_verify(&header, sizeof(gadget_header_info),1,fp_in);
fread_verify(&block_length_close,sizeof(int),1,fp_in);
fclose(fp_in);
if(block_length_open!=block_length_close)
SID_trap_error("Block lengths don't match (ie. %d!=%d).",ERROR_LOGIC,block_length_open,block_length_close);
}
SID_Bcast(&header,sizeof(gadget_header_info),MASTER_RANK,SID.COMM_WORLD);
redshift=header.redshift;
h_Hubble=header.h_Hubble;
box_size=header.box_size;
if(SID.n_proc>1)
n_load=1;
else
n_load=header.n_files;
for(i_species=0,n_total=0,n_used=0;i_species<N_GADGET_TYPE;i_species++){
n_all[i_species]=(size_t)header.n_all_lo_word[i_species]+((size_t)header.n_all_hi_word[i_species])<<32;
n_total+=n_all[i_species];
if(n_all[i_species]>0){
n_used++;
flag_used[i_species]=TRUE;
}
else
flag_used[i_species]=FALSE;
}
// Initialize cosmology
double box_size =((double *)ADaPS_fetch(plist.data,"box_size"))[0];
double h_Hubble =((double *)ADaPS_fetch(plist.data,"h_Hubble"))[0];
double redshift =((double *)ADaPS_fetch(plist.data,"redshift"))[0];
double expansion_factor=((double *)ADaPS_fetch(plist.data,"expansion_factor"))[0];
double Omega_M =((double *)ADaPS_fetch(plist.data,"Omega_M"))[0];
double Omega_Lambda =((double *)ADaPS_fetch(plist.data,"Omega_Lambda"))[0];
double Omega_k =1.-Omega_Lambda-Omega_M;
double Omega_b=0.; // not needed, so doesn't matter
double f_gas =Omega_b/Omega_M;
double sigma_8=0.; // not needed, so doesn't matter
double n_spec =0.; // not needed, so doesn't matter
char cosmo_name[16];
sprintf(cosmo_name,"Gadget file's");
init_cosmo(&cosmo,
cosmo_name,
Omega_Lambda,
Omega_M,
Omega_k,
Omega_b,
f_gas,
h_Hubble,
sigma_8,
n_spec);
}
SID_log("Done.",SID_LOG_CLOSE);
grid_identifier=(char *)SID_calloc(GRID_IDENTIFIER_SIZE*sizeof(char));
// Only process if there are >0 particles present
if(n_used>0){
// Loop over ithe real-space and 3 redshift-space frames
int i_write;
int i_run;
int n_run;
int n_grids_total;
n_grids_total=4; // For now, hard-wire real-space density and velocity grids only
n_run=1; // For now, hard-wire real-space calculation only
for(i_run=0,i_write=0;i_run<n_run;i_run++){
// Read catalog
int n_grid;
char i_run_identifier[8];
switch(i_run){
case 0:
SID_log("Processing real-space ...",SID_LOG_OPEN|SID_LOG_TIMER);
sprintf(i_run_identifier,"r");
n_grid=4;
break;
case 1:
SID_log("Processing v_x redshift space...",SID_LOG_OPEN|SID_LOG_TIMER);
sprintf(i_run_identifier,"x");
n_grid=1;
break;
case 2:
SID_log("Processing v_y redshift space...",SID_LOG_OPEN|SID_LOG_TIMER);
sprintf(i_run_identifier,"y");
n_grid=1;
break;
case 3:
SID_log("Processing v_z redsift space...",SID_LOG_OPEN|SID_LOG_TIMER);
sprintf(i_run_identifier,"z");
n_grid=1;
break;
}
// For each i_run case, loop over the fields we want to produce
int i_grid;
for(i_grid=0;i_grid<n_grid;i_grid++){
char i_grid_identifier[8];
switch(i_grid){
case 0:
SID_log("Processing density grid ...",SID_LOG_OPEN|SID_LOG_TIMER);
sprintf(i_grid_identifier,"rho");
break;
case 1:
SID_log("Processing v_x velocity grid...",SID_LOG_OPEN|SID_LOG_TIMER);
sprintf(i_grid_identifier,"v_x");
break;
case 2:
SID_log("Processing v_y velocity grid...",SID_LOG_OPEN|SID_LOG_TIMER);
sprintf(i_grid_identifier,"v_y");
break;
case 3:
SID_log("Processing v_z velocity grid...",SID_LOG_OPEN|SID_LOG_TIMER);
sprintf(i_grid_identifier,"v_z");
break;
}
// Initialize the field that will hold the grid
int n[]={grid_size,grid_size,grid_size};
double L[]={box_size, box_size, box_size};
int i_init;
for(i_species=0;i_species<N_GADGET_TYPE;i_species++){
if(flag_used[i_species]){
field[i_species] =(field_info *)SID_malloc(sizeof(field_info));
field_norm[i_species]=(field_info *)SID_malloc(sizeof(field_info));
init_field(3,n,L,field[i_species]);
init_field(3,n,L,field_norm[i_species]);
i_init=i_species;
}
else{
field[i_species] =NULL;
field_norm[i_species]=NULL;
}
}
// Loop over all the files that this rank will read
int i_load;
for(i_load=0;i_load<n_load;i_load++){
if(n_load>1)
SID_log("Processing file No. %d of %d...",SID_LOG_OPEN|SID_LOG_TIMER,i_load+1,n_load);
// Initialization -- read gadget file
GBPREAL mass_array[N_GADGET_TYPE];
init_plist(&plist,&((field[i_init])->slab),GADGET_LENGTH,GADGET_MASS,GADGET_VELOCITY);
char filename_root[MAX_FILENAME_LENGTH];
read_gadget_binary_local(filename_in_root,
snapshot_number,
i_run,
i_load,
n_load,
mass_array,
&(field[i_init]->slab),
cosmo,
&plist);
// Generate power spectra
for(i_species=0;i_species<plist.n_species;i_species++){
// Determine how many particles of species i_species there are
if(n_all[i_species]>0){
// Fetch the needed information
size_t n_particles;
size_t n_particles_local;
int flag_alloc_m;
GBPREAL *x_particles_local;
GBPREAL *y_particles_local;
GBPREAL *z_particles_local;
GBPREAL *vx_particles_local;
GBPREAL *vy_particles_local;
GBPREAL *vz_particles_local;
GBPREAL *m_particles_local;
GBPREAL *v_particles_local;
GBPREAL *w_particles_local;
n_particles =((size_t *)ADaPS_fetch(plist.data,"n_all_%s",plist.species[i_species]))[0];
n_particles_local=((size_t *)ADaPS_fetch(plist.data,"n_%s", plist.species[i_species]))[0];
x_particles_local= (GBPREAL *)ADaPS_fetch(plist.data,"x_%s", plist.species[i_species]);
y_particles_local= (GBPREAL *)ADaPS_fetch(plist.data,"y_%s", plist.species[i_species]);
z_particles_local= (GBPREAL *)ADaPS_fetch(plist.data,"z_%s", plist.species[i_species]);
vx_particles_local=(GBPREAL *)ADaPS_fetch(plist.data,"vx_%s", plist.species[i_species]);
vy_particles_local=(GBPREAL *)ADaPS_fetch(plist.data,"vy_%s", plist.species[i_species]);
vz_particles_local=(GBPREAL *)ADaPS_fetch(plist.data,"vz_%s", plist.species[i_species]);
if(ADaPS_exist(plist.data,"M_%s",plist.species[i_species])){
flag_alloc_m=FALSE;
m_particles_local=(GBPREAL *)ADaPS_fetch(plist.data,"M_%s",plist.species[i_species]);
}
else{
flag_alloc_m=TRUE;
m_particles_local=(GBPREAL *)SID_malloc(n_particles_local*sizeof(GBPREAL));
int i_particle;
for(i_particle=0;i_particle<n_particles_local;i_particle++)
m_particles_local[i_particle]=mass_array[i_species];
}
// Decide the map_to_grid() mode
int mode;
if(n_load==1)
mode=MAP2GRID_MODE_DEFAULT;
else if(i_load==0 || n_load==1)
mode=MAP2GRID_MODE_DEFAULT|MAP2GRID_MODE_NONORM;
else if(i_load==(n_load-1))
mode=MAP2GRID_MODE_NOCLEAN;
else
mode=MAP2GRID_MODE_NOCLEAN|MAP2GRID_MODE_NONORM;
// Set the array that will weight the grid
field_info *field_i;
field_info *field_norm_i;
double factor;
switch(i_grid){
case 0:
v_particles_local=m_particles_local;
w_particles_local=NULL;
field_i =field[i_species];
field_norm_i =NULL;
mode|=MAP2GRID_MODE_APPLYFACTOR;
factor=pow((double)grid_size/box_size,3.);
break;
case 1:
v_particles_local=vx_particles_local;
w_particles_local=m_particles_local;
field_i =field[i_species];
field_norm_i =field_norm[i_species];
factor=1.;
break;
case 2:
v_particles_local=vy_particles_local;
w_particles_local=m_particles_local;
field_i =field[i_species];
field_norm_i =field_norm[i_species];
factor=1.;
break;
case 3:
v_particles_local=vz_particles_local;
w_particles_local=m_particles_local;
field_i =field[i_species];
field_norm_i =field_norm[i_species];
factor=1.;
break;
}
// Generate grid
map_to_grid(n_particles_local,
x_particles_local,
y_particles_local,
z_particles_local,
v_particles_local,
w_particles_local,
cosmo,
redshift,
distribution_scheme,
factor,
field_i,
field_norm_i,
mode);
if(flag_alloc_m)
SID_free(SID_FARG m_particles_local);
}
}
// Clean-up
free_plist(&plist);
if(n_load>1)
SID_log("Done.",SID_LOG_CLOSE);
} // loop over i_load
// Write results to disk
char filename_out_species[MAX_FILENAME_LENGTH];
init_plist(&plist,NULL,GADGET_LENGTH,GADGET_MASS,GADGET_VELOCITY);
for(i_species=0;i_species<plist.n_species;i_species++){
if(flag_used[i_species]){
sprintf(grid_identifier,"%s_%s_%s",i_grid_identifier,i_run_identifier,plist.species[i_species]);
sprintf(filename_out_species,"%s_%s",filename_out_root,plist.species[i_species]);
write_grid(field[i_species],
filename_out_species,
i_write,
n_grids_total,
distribution_scheme,
grid_identifier,
header.box_size);
free_field(field[i_species]);
free_field(field_norm[i_species]);
SID_free(SID_FARG field[i_species]);
SID_free(SID_FARG field_norm[i_species]);
i_write++;
}
}
// Clean-up
free_plist(&plist);
SID_log("Done.",SID_LOG_CLOSE);
} // loop over i_grid
SID_log("Done.",SID_LOG_CLOSE);
} // loop over i_run
} // if n_used>0
// Clean-up
free_cosmo(&cosmo);
SID_free(SID_FARG grid_identifier);
SID_free(SID_FARG n_all);
SID_log("Done.",SID_LOG_CLOSE);
SID_exit(ERROR_NONE);
}
