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_search; int n_files; int k_read; int max_n_groups; int l_read; int * n_particles_i; int * n_particles_j; int n_groups_i; int n_groups_j; int * match_ids; float * match_score; size_t *match_index; 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); // Fetch user inputs if(argc != 12) SID_exit_error("Invalid Syntax.", SID_ERROR_SYNTAX); char filename_SSimPL_root[SID_MAX_FILENAME_LENGTH]; char filename_halos_root[SID_MAX_FILENAME_LENGTH]; char filename_trees_root[SID_MAX_FILENAME_LENGTH]; char filename_out_root[SID_MAX_FILENAME_LENGTH]; strcpy(filename_SSimPL_root, argv[1]); strcpy(filename_halos_root, argv[2]); strcpy(filename_trees_root, argv[3]); double x_cen = (double)atof(argv[4]); double y_cen = (double)atof(argv[5]); double z_cen = (double)atof(argv[6]); double radius = (double)atof(argv[7]); double z_min_in = (double)atof(argv[8]); double z_max_in = (double)atof(argv[9]); double M_min = (double)atof(argv[10]); strcpy(filename_out_root, argv[11]); double radius2 = radius * radius; SID_log("Query trees for sphere (x,y,z,r)=(%.2lf,%.2lf,%.2lf,%.2lf) between z=%.2lf and z=%.2lf...", SID_LOG_OPEN, x_cen, y_cen, z_cen, radius, z_min_in, z_max_in); char filename_catalog_root[SID_MAX_FILENAME_LENGTH]; sprintf(filename_catalog_root, "%s/catalogs/%s", filename_SSimPL_root, filename_halos_root); // Read tree header information tree_info *trees; char filename_file_root[SID_MAX_FILENAME_LENGTH]; sprintf(filename_file_root, "%s/trees/%s", filename_SSimPL_root, filename_trees_root); SID_set_verbosity(SID_SET_VERBOSITY_RELATIVE, 0); init_trees_read(filename_SSimPL_root, filename_halos_root, filename_trees_root, TREE_READ_HEADER_ONLY, &trees); SID_set_verbosity(SID_SET_VERBOSITY_DEFAULT); // Turn given redshift range into snapshot range int i_snap_min_z = find_treesnap_z(trees, z_max_in); int i_snap_max_z = find_treesnap_z(trees, z_min_in); SID_log("z=%.2lf -> snapshot=%d", SID_LOG_COMMENT, z_min_in, trees->snap_list[i_snap_max_z]); SID_log("z=%.2lf -> snapshot=%d", SID_LOG_COMMENT, z_max_in, trees->snap_list[i_snap_min_z]); // Perform query int n_groups_list = 0; int n_subgroups_list = 0; int *group_list = NULL; int *subgroup_list = NULL; for(int i_pass = 0; i_pass < 3; i_pass++) { if(i_pass == 0) SID_log("Counting halos to be queried...", SID_LOG_OPEN | SID_LOG_TIMER); else if(i_pass == 1) SID_log("Identifying halos to be queried...", SID_LOG_OPEN | SID_LOG_TIMER); else if(i_pass == 2) SID_log("Performing query...", SID_LOG_OPEN | SID_LOG_TIMER); // Write headers if(i_pass == 2) { for(int i_type = 0; i_type < 2; i_type++) { int n_list = 0; int *halo_list = NULL; if(i_type == 0) { n_list = n_groups_list; halo_list = group_list; } else { n_list = n_subgroups_list; halo_list = subgroup_list; } for(int i_list = 0; i_list < n_list; i_list++) { int i_column = 1; char filename_out[SID_MAX_FILENAME_LENGTH]; if(i_type == 0) sprintf(filename_out, "%s_group_%09d.txt", filename_out_root, halo_list[i_list]); else sprintf(filename_out, "%s_subgroup_%09d.txt", filename_out_root, halo_list[i_list]); FILE *fp_out = fopen(filename_out, "w"); fprintf(fp_out, "# Column (%02d): Halo expansion factor\n", i_column++); fprintf(fp_out, "# (%02d): Halo redshift\n", i_column++); fprintf(fp_out, "# (%02d): Halo snapshot\n", i_column++); fprintf(fp_out, "# (%02d): Halo index\n", i_column++); fprintf(fp_out, "# (%02d): Halo ID\n", i_column++); fprintf(fp_out, "# (%02d): Halo log10(M_vir [M_sol/h])\n", i_column++); fprintf(fp_out, "# (%02d): Halo n_particles\n", i_column++); fprintf(fp_out, "# (%02d): Halo n_particles_peak\n", i_column++); fprintf(fp_out, "# (%02d): Halo x [Mpc/h])\n", i_column++); fprintf(fp_out, "# (%02d): Halo y [Mpc/h])\n", i_column++); fprintf(fp_out, "# (%02d): Halo z [Mpc/h])\n", i_column++); fprintf(fp_out, "# (%02d): Halo radius [Mpc/h])\n", i_column++); fprintf(fp_out, "# (%02d): Halo tree ID\n", i_column++); fprintf(fp_out, "# (%02d): Descendant file offset\n", i_column++); fprintf(fp_out, "# (%02d): Descendant snapshot\n", i_column++); fprintf(fp_out, "# (%02d): Descendant index\n", i_column++); fprintf(fp_out, "# (%02d): Descendant ID\n", i_column++); fprintf(fp_out, "# (%02d): Bridge forematch snapshot\n", i_column++); fprintf(fp_out, "# (%02d): Bridge forematch index\n", i_column++); fprintf(fp_out, "# (%02d): Bridge backmatch snapshot\n", i_column++); fprintf(fp_out, "# (%02d): Bridge backmatch index\n", i_column++); fprintf(fp_out, "# (%02d): Halo type\n", i_column++); fprintf(fp_out, "# (%02d): Halo type string\n", i_column++); if(i_type == 1) { fprintf(fp_out, "# (%02d): Group index\n", i_column++); fprintf(fp_out, "# (%02d): Group ID\n", i_column++); fprintf(fp_out, "# (%02d): Subgroup index\n", i_column++); fprintf(fp_out, "# (%02d): FoF Centre dx [Mpc/h])\n", i_column++); fprintf(fp_out, "# (%02d): FoF Centre dy [Mpc/h])\n", i_column++); fprintf(fp_out, "# (%02d): FoF Centre dz [Mpc/h])\n", i_column++); } fclose(fp_out); } } } // Set the snapshot range we need to scan int i_snap_start; int i_snap_stop; if(i_pass < 2) { i_snap_start = i_snap_min_z; i_snap_stop = i_snap_max_z; } else { i_snap_start = 0; i_snap_stop = trees->n_snaps - 1; } // Loop over the range of snapshots int i_list = 0; for(int i_snap = i_snap_start; i_snap <= i_snap_stop; i_snap++) { // Get the snapshot int snapshot = trees->snap_list[i_snap]; if(i_pass == 2) SID_log("Processing snapshot %03d...", SID_LOG_OPEN, snapshot); // Open properties for this snapshot fp_catalog_info fp_properties_groups; fp_catalog_info fp_properties_subgroups; halo_properties_info properties_groups; halo_properties_info properties_subgroups; fopen_catalog(filename_catalog_root, snapshot, READ_CATALOG_GROUPS | READ_CATALOG_PROPERTIES, &fp_properties_groups); fopen_catalog(filename_catalog_root, snapshot, READ_CATALOG_SUBGROUPS | READ_CATALOG_PROPERTIES, &fp_properties_subgroups); // Open horizontal trees for this snapshot SID_fp fp_in_trees; SID_fp fp_in_bridge_forematch; SID_fp fp_in_bridge_backmatch; char filename_in[SID_MAX_FILENAME_LENGTH]; sprintf(filename_in, "%s/trees/%s/horizontal/trees/horizontal_trees_%03d.dat", filename_SSimPL_root, filename_trees_root, snapshot); SID_fopen(filename_in, "r", &fp_in_trees); sprintf(filename_in, "%s/trees/%s/horizontal/trees/horizontal_trees_forematch_pointers_%03d.dat", filename_SSimPL_root, filename_trees_root, snapshot); SID_fopen(filename_in, "r", &fp_in_bridge_forematch); sprintf(filename_in, "%s/trees/%s/horizontal/trees/horizontal_trees_backmatch_pointers_%03d.dat", filename_SSimPL_root, filename_trees_root, snapshot); SID_fopen(filename_in, "r", &fp_in_bridge_backmatch); // Read trees header int n_step_in; int n_search_in; int n_groups; int n_subgroups; int n_groups_max_in; int n_subgroups_max_in; int n_trees_subgroup_in; int n_trees_group_in; SID_fread_all(&n_step_in, sizeof(int), 1, &fp_in_trees); SID_fread_all(&n_search_in, sizeof(int), 1, &fp_in_trees); SID_fread_all(&n_groups, sizeof(int), 1, &fp_in_trees); SID_fread_all(&n_subgroups, sizeof(int), 1, &fp_in_trees); SID_fread_all(&n_groups_max_in, sizeof(int), 1, &fp_in_trees); SID_fread_all(&n_subgroups_max_in, sizeof(int), 1, &fp_in_trees); SID_fread_all(&n_trees_subgroup_in, sizeof(int), 1, &fp_in_trees); SID_fread_all(&n_trees_group_in, sizeof(int), 1, &fp_in_trees); SID_fskip(sizeof(int), 8, &fp_in_bridge_forematch); SID_fskip(sizeof(int), 8, &fp_in_bridge_backmatch); // Scan through the trees int i_subgroup = 0; for(int i_group = 0; i_group < n_groups; i_group++) { // Read group int group_id; int group_type; int group_descendant_id; int group_tree_id; int group_file_offset; int group_index; int group_n_particles_peak; int n_subgroups_group; int group_forematch_id; int group_forematch_first_file; int group_forematch_first_index; float group_forematch_first_score; int group_forematch_default_file; int group_forematch_default_index; float group_forematch_default_score; int group_forematch_best_file; int group_forematch_best_index; float group_forematch_best_score; float group_forematch_score_prog; int group_backmatch_id; int group_backmatch_file; int group_backmatch_index; float group_backmatch_score; float group_backmatch_score_prog; SID_fread_all(&group_id, sizeof(int), 1, &fp_in_trees); SID_fread_all(&group_type, sizeof(int), 1, &fp_in_trees); SID_fread_all(&group_descendant_id, sizeof(int), 1, &fp_in_trees); SID_fread_all(&group_tree_id, sizeof(int), 1, &fp_in_trees); SID_fread_all(&group_file_offset, sizeof(int), 1, &fp_in_trees); SID_fread_all(&group_index, sizeof(int), 1, &fp_in_trees); SID_fread_all(&group_n_particles_peak, sizeof(int), 1, &fp_in_trees); SID_fread_all(&n_subgroups_group, sizeof(int), 1, &fp_in_trees); SID_fread_all(&group_forematch_id, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&group_forematch_first_file, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&group_forematch_first_index, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&group_forematch_first_score, sizeof(float), 1, &fp_in_bridge_forematch); SID_fread_all(&group_forematch_default_file, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&group_forematch_default_index, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&group_forematch_default_score, sizeof(float), 1, &fp_in_bridge_forematch); SID_fread_all(&group_forematch_best_file, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&group_forematch_best_index, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&group_forematch_best_score, sizeof(float), 1, &fp_in_bridge_forematch); SID_fread_all(&group_forematch_score_prog, sizeof(float), 1, &fp_in_bridge_forematch); SID_fread_all(&group_backmatch_id, sizeof(int), 1, &fp_in_bridge_backmatch); SID_fread_all(&group_backmatch_file, sizeof(int), 1, &fp_in_bridge_backmatch); SID_fread_all(&group_backmatch_index, sizeof(int), 1, &fp_in_bridge_backmatch); SID_fread_all(&group_backmatch_score, sizeof(float), 1, &fp_in_bridge_backmatch); SID_fread_all(&group_backmatch_score_prog, sizeof(float), 1, &fp_in_bridge_backmatch); SID_fskip(sizeof(int), 1, &fp_in_bridge_forematch); // skip subhalo count SID_fskip(sizeof(int), 1, &fp_in_bridge_backmatch); // skip subhalo count fread_catalog_file(&fp_properties_groups, NULL, NULL, &properties_groups, NULL, i_group); // Process group process_local(trees, i_pass, filename_out_root, radius2, M_min, i_snap, i_group, 0, i_group, group_id, group_file_offset, group_type, group_n_particles_peak, group_tree_id, group_index, group_descendant_id, group_forematch_first_index, group_forematch_first_file, group_backmatch_index, group_backmatch_file, group_id, &properties_groups, NULL, &n_groups_list, group_list, x_cen, y_cen, z_cen); for(int j_subgroup = 0; j_subgroup < n_subgroups_group; i_subgroup++, j_subgroup++) { // Read subgroup int subgroup_id; int subgroup_type; int subgroup_descendant_id; int subgroup_tree_id; int subgroup_file_offset; int subgroup_index; int subgroup_n_particles_peak; int subgroup_forematch_id; int subgroup_forematch_first_file; int subgroup_forematch_first_index; float subgroup_forematch_first_score; int subgroup_forematch_default_file; int subgroup_forematch_default_index; float subgroup_forematch_default_score; int subgroup_forematch_best_file; int subgroup_forematch_best_index; float subgroup_forematch_best_score; float subgroup_forematch_score_prog; int subgroup_backmatch_id; int subgroup_backmatch_file; int subgroup_backmatch_index; float subgroup_backmatch_score; float subgroup_backmatch_score_prog; SID_fread_all(&subgroup_id, sizeof(int), 1, &fp_in_trees); SID_fread_all(&subgroup_type, sizeof(int), 1, &fp_in_trees); SID_fread_all(&subgroup_descendant_id, sizeof(int), 1, &fp_in_trees); SID_fread_all(&subgroup_tree_id, sizeof(int), 1, &fp_in_trees); SID_fread_all(&subgroup_file_offset, sizeof(int), 1, &fp_in_trees); SID_fread_all(&subgroup_index, sizeof(int), 1, &fp_in_trees); SID_fread_all(&subgroup_n_particles_peak, sizeof(int), 1, &fp_in_trees); SID_fread_all(&subgroup_forematch_id, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&subgroup_forematch_first_file, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&subgroup_forematch_first_index, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&subgroup_forematch_first_score, sizeof(float), 1, &fp_in_bridge_forematch); SID_fread_all(&subgroup_forematch_default_file, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&subgroup_forematch_default_index, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&subgroup_forematch_default_score, sizeof(float), 1, &fp_in_bridge_forematch); SID_fread_all(&subgroup_forematch_best_file, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&subgroup_forematch_best_index, sizeof(int), 1, &fp_in_bridge_forematch); SID_fread_all(&subgroup_forematch_best_score, sizeof(float), 1, &fp_in_bridge_forematch); SID_fread_all(&subgroup_forematch_score_prog, sizeof(float), 1, &fp_in_bridge_forematch); SID_fread_all(&subgroup_backmatch_id, sizeof(int), 1, &fp_in_bridge_backmatch); SID_fread_all(&subgroup_backmatch_file, sizeof(int), 1, &fp_in_bridge_backmatch); SID_fread_all(&subgroup_backmatch_index, sizeof(int), 1, &fp_in_bridge_backmatch); SID_fread_all(&subgroup_backmatch_score, sizeof(float), 1, &fp_in_bridge_backmatch); SID_fread_all(&subgroup_backmatch_score_prog, sizeof(float), 1, &fp_in_bridge_backmatch); fread_catalog_file(&fp_properties_subgroups, NULL, NULL, &properties_subgroups, NULL, i_subgroup); // Process subgroup process_local(trees, i_pass, filename_out_root, radius2, M_min, i_snap, i_subgroup, j_subgroup, i_group, subgroup_id, subgroup_file_offset, subgroup_type, subgroup_n_particles_peak, subgroup_tree_id, subgroup_index, subgroup_descendant_id, subgroup_forematch_first_index, subgroup_forematch_first_file, subgroup_backmatch_index, subgroup_backmatch_file, group_id, &properties_subgroups, &properties_groups, &n_subgroups_list, subgroup_list, x_cen, y_cen, z_cen); } } fclose_catalog(&fp_properties_groups); fclose_catalog(&fp_properties_subgroups); SID_fclose(&fp_in_trees); SID_fclose(&fp_in_bridge_forematch); SID_fclose(&fp_in_bridge_backmatch); if(i_pass == 2) SID_log("Done.", SID_LOG_CLOSE); } // i_snap if(i_pass == 0) { group_list = (int *)SID_malloc(sizeof(int) * n_groups_list); subgroup_list = (int *)SID_malloc(sizeof(int) * n_subgroups_list); n_groups_list = 0; n_subgroups_list = 0; } else if(i_pass == 1) { SID_log("(%d groups and %d subgroups found)...", SID_LOG_CONTINUE, n_groups_list, n_subgroups_list); // Write list files for(int i_type = 0; i_type < 2; i_type++) { char filename_out[SID_MAX_FILENAME_LENGTH]; int n_list = 0; int *halo_list = NULL; if(i_type == 0) { sprintf(filename_out, "%s_group_list.txt", filename_out_root); n_list = n_groups_list; halo_list = group_list; } else { sprintf(filename_out, "%s_subgroup_list.txt", filename_out_root); n_list = n_subgroups_list; halo_list = subgroup_list; } FILE *fp_out = fopen(filename_out, "w"); fprintf(fp_out, "# Halo IDs in list of tree tracks with base {%s}\n", filename_out_root); for(int i_list = 0; i_list < n_list; i_list++) fprintf(fp_out, "%d\n", halo_list[i_list]); fclose(fp_out); } } SID_log("Done.", SID_LOG_CLOSE); } // Clean-up SID_free(SID_FARG group_list); SID_free(SID_FARG subgroup_list); free_trees(&trees); SID_log("Done.", SID_LOG_CLOSE); SID_Finalize(); }
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[]) { SID_Init(&argc, &argv, NULL); // Fetch user inputs char filename_halos_root[256]; char filename_catalog_root[256]; char filename_PHKs_root[256]; double box_size; double dx; int i_file_lo_in; int i_file_hi_in; int i_file_skip; strcpy(filename_halos_root, argv[1]); strcpy(filename_catalog_root, argv[2]); strcpy(filename_PHKs_root, argv[3]); box_size = atof(argv[4]); dx = atof(argv[5]); i_file_lo_in = atoi(argv[6]); i_file_hi_in = atoi(argv[7]); i_file_skip = atoi(argv[8]); int i_file_lo; int i_file_hi; if(i_file_lo_in < i_file_hi_in) { i_file_lo = i_file_lo_in; i_file_hi = i_file_hi_in; } else { i_file_lo = i_file_hi_in; i_file_hi = i_file_lo_in; } SID_log("Generating group PH keys for files #%d->#%d...", SID_LOG_OPEN | SID_LOG_TIMER, i_file_lo, i_file_hi); for(int i_file = i_file_lo; i_file <= i_file_hi; i_file += i_file_skip) { SID_log("Processing file #%03d...", SID_LOG_OPEN | SID_LOG_TIMER, i_file); SID_set_verbosity(SID_SET_VERBOSITY_RELATIVE, 0); // Read group info from the halo catalogs plist_info plist; int * PHK_group = NULL; size_t * PHK_group_index = NULL; char * filename_number = (char *)SID_malloc(sizeof(char) * 10); init_plist(&plist, NULL, GADGET_LENGTH, GADGET_MASS, GADGET_VELOCITY); sprintf(filename_number, "%03d", i_file); ADaPS_store(&(plist.data), (void *)filename_number, "read_catalog", ADaPS_DEFAULT); read_groups(filename_halos_root, i_file, READ_GROUPS_ALL | READ_GROUPS_MBP_IDS_ONLY, &plist, filename_number); int n_groups_all = ((int *)ADaPS_fetch(plist.data, "n_groups_all_%s", filename_number))[0]; int n_groups = ((int *)ADaPS_fetch(plist.data, "n_groups_%s", filename_number))[0]; // If there's any groups to analyze ... int * n_particles_groups = NULL; size_t n_particles_cumulative = 0; int n_bits = 0; // Default value if there are no groups if(n_groups > 0) { // Fetch the halo sizes n_particles_groups = (int *)ADaPS_fetch(plist.data, "n_particles_group_%s", filename_number); // Read MBP data from halo catalogs SID_log("Reading most-bound-particle positions...", SID_LOG_OPEN); halo_properties_info group_properties; fp_catalog_info fp_group_properties; double * x_array = (double *)SID_malloc(sizeof(double) * n_groups); double * y_array = (double *)SID_malloc(sizeof(double) * n_groups); double * z_array = (double *)SID_malloc(sizeof(double) * n_groups); fopen_catalog(filename_catalog_root, i_file, READ_CATALOG_GROUPS | READ_CATALOG_PROPERTIES, &fp_group_properties); if(fp_group_properties.n_halos_total != n_groups) SID_exit_error("Halo counts in group files and catalogs don't match (ie. %d!=%d)", SID_ERROR_LOGIC, fp_group_properties.n_halos_total, n_groups); for(int i_group = 0; i_group < n_groups; i_group++) { fread_catalog_file(&fp_group_properties, NULL, NULL, &group_properties, NULL, i_group); x_array[i_group] = group_properties.position_MBP[0]; y_array[i_group] = group_properties.position_MBP[1]; z_array[i_group] = group_properties.position_MBP[2]; // Enforce periodic BCs if(x_array[i_group] < 0.) x_array[i_group] += box_size; if(x_array[i_group] >= box_size) x_array[i_group] -= box_size; if(y_array[i_group] < 0.) y_array[i_group] += box_size; if(y_array[i_group] >= box_size) y_array[i_group] -= box_size; if(z_array[i_group] < 0.) z_array[i_group] += box_size; if(z_array[i_group] >= box_size) z_array[i_group] -= box_size; } fclose_catalog(&fp_group_properties); SID_log("Done.", SID_LOG_CLOSE); // Determine the number of bits to use for the PHKs for(n_bits = N_BITS_MIN; (box_size / pow(2., (double)(n_bits + 1))) > dx && n_bits <= 20;) n_bits++; // Compute PHKs SID_log("Computing PHKs (using %d bits per dimension)...", SID_LOG_OPEN, n_bits); PHK_group = (int *)SID_malloc(sizeof(int) * n_groups); for(int i_group = 0; i_group < n_groups; i_group++) { // Compute the key for this group PHK_group[i_group] = compute_PHK_from_Cartesian( n_bits, 3, (double)x_array[i_group] / box_size, (double)y_array[i_group] / box_size, (double)z_array[i_group] / box_size); } SID_free(SID_FARG x_array); SID_free(SID_FARG y_array); SID_free(SID_FARG z_array); SID_log("Done.", SID_LOG_CLOSE); // Sort PHKs SID_log("Sorting PHKs...", SID_LOG_OPEN); merge_sort((void *)PHK_group, n_groups, &PHK_group_index, SID_INT, SORT_COMPUTE_INDEX, GBP_FALSE); SID_log("Done.", SID_LOG_CLOSE); // Count the number of particles for(int i_group = 0; i_group < n_groups; i_group++) n_particles_cumulative += n_particles_groups[PHK_group_index[i_group]]; } // Write results SID_log("Writing results for %d groups...", SID_LOG_OPEN, n_groups); char filename_output_properties[256]; sprintf(filename_output_properties, "%s_%s.catalog_PHKs", filename_PHKs_root, filename_number); FILE *fp_PHKs = fopen(filename_output_properties, "w"); fwrite(&n_groups, sizeof(int), 1, fp_PHKs); fwrite(&n_bits, sizeof(int), 1, fp_PHKs); fwrite(&n_particles_cumulative, sizeof(size_t), 1, fp_PHKs); n_particles_cumulative = 0; for(int i_group = 0; i_group < n_groups; i_group++) { int index_temp = (int)PHK_group_index[i_group]; n_particles_cumulative += n_particles_groups[index_temp]; fwrite(&(PHK_group[index_temp]), sizeof(int), 1, fp_PHKs); fwrite(&index_temp, sizeof(int), 1, fp_PHKs); fwrite(&n_particles_cumulative, sizeof(size_t), 1, fp_PHKs); } fclose(fp_PHKs); SID_log("Done.", SID_LOG_CLOSE); // Clean-up free_plist(&plist); if(n_groups > 0) { SID_free(SID_FARG PHK_group); SID_free(SID_FARG PHK_group_index); } SID_set_verbosity(SID_SET_VERBOSITY_DEFAULT); SID_log("Done.", SID_LOG_CLOSE); } SID_log("Done.", SID_LOG_CLOSE); SID_Finalize(); }