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();
}
