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[]) {
plist_info plist;
char filename_root[256];
char filename_log[256];
char filename_number[256];
char filename_in_halos[256];
char filename_out_groups[256];
char filename_out_groups_A[256];
char filename_out_groups_B[256];
char filename_out_groups_C[256];
char filename_out_subgroups[256];
char filename_out_subgroups_A[256];
char filename_out_subgroups_B[256];
char filename_out_hierarchy[256];
char filename_out_hierarchy_A[256];
char filename_out_hierarchy_B[256];
char filename_out_particles[256];
char i_match_txt[5];
int n_groups_AHF;
int n_groups;
int n_subgroups;
int n_subgroups_matched;
int n_subgroups_group;
size_t n_particles;
size_t n_particles_in_groups;
size_t n_particles_in_subgroups;
size_t n_particles_AHF_not_used;
int n_particles_temp;
int * n_p_1 = NULL;
int flag_continue;
int flag_long_ids;
int i_match;
int match_id_next;
int * match_id = NULL;
int * match_id_initial = NULL;
FILE * fp = NULL;
FILE * fp_in_halos = NULL;
FILE * fp_out = NULL;
int n_match;
int * id_2 = NULL;
size_t * particle_ids_AHF = NULL;
size_t * particle_ids_AHF_index = NULL;
size_t id_largest;
int id_byte_size;
size_t * group_particles = NULL;
int group_id;
int subgroup_id;
int i_group;
int j_group;
int k_group;
size_t n_particles_AHF;
int * subgroup_size = NULL;
int * hierarchy_level = NULL;
int * hierarchy_match = NULL;
int subgroup_size_max;
int * subgroup_size_list = NULL;
int * subgroup_index_list = NULL;
size_t * subgroup_size_list_index = NULL;
int * group_offsets = NULL;
size_t group_index;
int * group_size = NULL;
int * group_size_AHF = NULL;
int * group_offsets_AHF = NULL;
int max_subgroup_size;
int i_subgroup;
int j_subgroup;
int n_subgroups_group_max;
size_t * group_size_index = NULL;
size_t * match_id_index = NULL;
size_t subgroup_index;
int group_offset;
int subgroup_offset;
int group_count;
size_t * group_particles_index = NULL;
size_t * subgroup_particles = NULL;
int * particle_group = NULL;
size_t * particle_group_index = NULL;
size_t i_particle;
size_t j_particle;
size_t k_particle;
int i_file;
int i_file_start;
int i_file_stop;
size_t * match_index = NULL;
int flag_match_subgroups;
FILE * fp_log = NULL;
FILE * fp_in = NULL;
FILE * fp_out_particles = NULL;
FILE * fp_out_groups = NULL;
FILE * fp_out_groups_A = NULL;
FILE * fp_out_groups_B = NULL;
FILE * fp_out_groups_C = NULL;
FILE * fp_out_subgroups_A = NULL;
FILE * fp_out_subgroups_B = NULL;
FILE * fp_out_hierarchy_A = NULL;
FILE * fp_out_hierarchy_B = NULL;
FILE * fp_test = NULL;
int substructure_level;
int substructure_level_max;
halo_properties_info *properties = NULL;
void * particle_buffer = NULL;
int flag_found;
SID_Init(&argc, &argv, NULL);
strcpy(filename_root, argv[1]);
i_file_start = atoi(argv[2]);
i_file_stop = atoi(argv[3]);
SID_log("Converting files #%d->#%d from AHF to subfind format...", SID_LOG_OPEN | SID_LOG_TIMER, i_file_start, i_file_stop);
sprintf(filename_log, "%s_%dto%d.convert_AHF_log", filename_root, i_file_start, i_file_stop);
// Loop over all files
for(i_file = i_file_start; i_file <= i_file_stop; i_file++) {
SID_log("Processing file #%d...", SID_LOG_OPEN | SID_LOG_TIMER, i_file);
// Read catalogs
if(i_file < 10)
sprintf(filename_number, "00%1d", i_file);
else if(i_file < 100)
sprintf(filename_number, "0%2d", i_file);
else
sprintf(filename_number, "%3d", i_file);
// Read AHF group file
init_plist(&plist, NULL, GADGET_LENGTH, GADGET_MASS, GADGET_VELOCITY);
read_groups_AHF(filename_root, i_file, READ_GROUPS_ALL, &plist, filename_number);
n_groups_AHF = ((int *)ADaPS_fetch(plist.data, "n_groups_%s", filename_number))[0];
n_groups = 0;
n_subgroups = 0;
n_subgroups_matched = 0;
n_subgroups_group = 0;
n_particles = 0;
n_particles_in_groups = 0;
n_particles_in_subgroups = 0;
n_particles_AHF_not_used = 0;
n_subgroups_group_max = 0;
if(n_groups_AHF > 0) {
n_particles_AHF = (size_t)((size_t *)ADaPS_fetch(plist.data, "n_particles_%s", filename_number))[0];
group_size_AHF = (int *)ADaPS_fetch(plist.data, "n_particles_group_%s", filename_number);
group_offsets_AHF = (int *)ADaPS_fetch(plist.data, "particle_offset_group_%s", filename_number);
particle_ids_AHF = (size_t *)ADaPS_fetch(plist.data, "particle_ids_%s", filename_number);
// Find largest id so we know what size to write the ids with
for(i_particle = 0, id_largest = 0; i_particle < n_particles_AHF; i_particle++)
id_largest = GBP_MAX(id_largest, particle_ids_AHF[i_particle]);
if(id_largest > INT_MAX) {
flag_long_ids = GBP_TRUE;
id_byte_size = sizeof(size_t);
} else {
flag_long_ids = GBP_FALSE;
id_byte_size = sizeof(int);
}
// Match AHF groups against themselves to find substructure
match_halos(&plist, NULL, i_file, NULL, 0, &plist, NULL, i_file, NULL, 0, "substructure", MATCH_SUBSTRUCTURE, MATCH_SCORE_RANK_INDEX);
match_id_initial = (int *)ADaPS_fetch(plist.data, "match_substructure");
hierarchy_match = match_id_initial; // Fore readability
// Assign sub-...-sub-structures to parent (ie. top-level) halos
SID_log("Assigning substructures to groups...", SID_LOG_OPEN);
group_size = (int *)SID_malloc(sizeof(int) * n_groups_AHF);
subgroup_size = (int *)SID_malloc(sizeof(int) * n_groups_AHF);
hierarchy_level = (int *)SID_malloc(sizeof(int) * n_groups_AHF);
particle_group = (int *)SID_malloc(sizeof(int) * n_particles_AHF);
for(i_group = 0, i_particle = 0; i_group < n_groups_AHF; i_group++) {
group_size[i_group] = 0;
subgroup_size[i_group] = 0;
for(j_particle = 0; j_particle < group_size_AHF[i_group]; i_particle++, j_particle++)
particle_group[i_particle] = i_group;
}
match_id = (int *)SID_malloc(sizeof(int) * n_groups_AHF);
for(i_group = 0, substructure_level_max = 0; i_group < n_groups_AHF; i_group++) {
substructure_level = 0;
match_id_next = match_id_initial[i_group];
match_id[i_group] = match_id_next;
while(match_id_next >= 0) {
substructure_level++;
match_id[i_group] = match_id_next; // Tie subgroups to their top-level group
match_id_next = match_id_initial[match_id_next];
}
if(match_id[i_group] < 0)
match_id[i_group] = i_group; // Unmatched halos should be matched to themselves
hierarchy_level[i_group] = substructure_level;
substructure_level_max = GBP_MAX(substructure_level, substructure_level_max);
}
// needed? ADaPS_store(&(plist.data),(void *)(match_id),"match_substructure",ADaPS_DEFAULT);
SID_log("Done.", SID_LOG_CLOSE);
// Make sure the deepest substructures are given particle ownership
SID_log("Assigning particles to subgroups...", SID_LOG_OPEN);
merge_sort(
(void *)particle_ids_AHF, (size_t)n_particles_AHF, &particle_ids_AHF_index, SID_SIZE_T, SORT_COMPUTE_INDEX, SORT_COMPUTE_NOT_INPLACE);
for(i_particle = 0, n_particles_AHF_not_used = 0; i_particle < n_particles_AHF; i_particle += k_particle) {
// Count the number of times this particle id is used
j_particle = i_particle;
while(particle_ids_AHF[particle_ids_AHF_index[j_particle]] == particle_ids_AHF[particle_ids_AHF_index[i_particle]] &&
j_particle < (n_particles_AHF - 2))
j_particle++;
if(particle_ids_AHF[particle_ids_AHF_index[j_particle]] == particle_ids_AHF[particle_ids_AHF_index[i_particle]])
j_particle++;
k_particle = j_particle - i_particle;
// Find the deepest substructure using this particle id...
i_group = particle_group[particle_ids_AHF_index[i_particle]];
for(j_particle = 1; j_particle < k_particle; j_particle++) {
j_group = particle_group[particle_ids_AHF_index[i_particle + j_particle]];
if(group_size_AHF[j_group] < group_size_AHF[i_group])
i_group = j_group;
}
// ... and set particle's group to a dummy value if this particle instance is not from the deepest group
for(j_particle = 0, flag_found = GBP_FALSE; j_particle < k_particle; j_particle++) {
if(particle_group[particle_ids_AHF_index[i_particle + j_particle]] != i_group || flag_found) {
particle_group[particle_ids_AHF_index[i_particle + j_particle]] = -1;
n_particles_AHF_not_used++;
} else
flag_found = GBP_TRUE;
}
}
SID_free((void **)&particle_ids_AHF_index);
SID_log("Done.", SID_LOG_CLOSE);
// Generate subgroup_size array
for(i_group = 0; i_group < n_groups_AHF; i_group++)
subgroup_size[i_group] = 0;
for(i_particle = 0; i_particle < n_particles_AHF; i_particle++) {
i_group = particle_group[i_particle];
if(i_group >= 0)
subgroup_size[i_group]++;
}
// Get rid of groups that are too small
for(i_particle = 0; i_particle < n_particles_AHF; i_particle++) {
i_group = particle_group[i_particle];
if(i_group >= 0) {
if(subgroup_size[i_group] < 20) {
n_particles_AHF_not_used++;
particle_group[i_particle] = -1;
}
}
}
// Regenerate subgroup_size array
for(i_group = 0; i_group < n_groups_AHF; i_group++)
subgroup_size[i_group] = 0;
for(i_particle = 0; i_particle < n_particles_AHF; i_particle++) {
i_group = particle_group[i_particle];
if(i_group >= 0)
subgroup_size[i_group]++;
}
// Find the largest subgroup's size
for(i_group = 0, n_subgroups = 0, subgroup_size_max = 0; i_group < n_groups_AHF; i_group++)
subgroup_size_max = GBP_MAX(subgroup_size[i_group], subgroup_size_max);
// Generate group_size array
for(i_group = 0; i_group < n_groups_AHF; i_group++)
group_size[match_id[i_group]] += subgroup_size[i_group]; // update group size
// Sort groups in order of size
merge_sort((void *)group_size, (size_t)n_groups_AHF, &group_size_index, SID_INT, SORT_COMPUTE_INDEX, SORT_COMPUTE_NOT_INPLACE);
merge_sort((void *)match_id, (size_t)n_groups_AHF, &match_id_index, SID_INT, SORT_COMPUTE_INDEX, SORT_COMPUTE_NOT_INPLACE);
// Count groups, subgroups, etc.
SID_log("Counting groups & subgroups...", SID_LOG_OPEN);
for(i_group = 0, n_groups = 0, n_subgroups = 0; i_group < n_groups_AHF; i_group++) {
group_index = group_size_index[n_groups_AHF - i_group - 1];
// Find start of subgroup list for this group
j_group = find_index_int(match_id, group_index, n_groups_AHF, match_id_index);
while(group_index > match_id[match_id_index[j_group]] && j_group < (n_groups_AHF - 2))
j_group++;
if(group_index > match_id[match_id_index[j_group]])
j_group++;
// Count subgroups
n_subgroups_group = 0;
while(match_id[match_id_index[j_group]] == group_index && j_group < (n_groups_AHF - 2)) {
if(subgroup_size[match_id_index[j_group]] > 0)
n_subgroups_group++;
j_group++;
}
if(match_id[match_id_index[j_group]] == group_index) {
if(subgroup_size[match_id_index[j_group]] > 0)
n_subgroups_group++;
j_group++;
}
n_subgroups += n_subgroups_group;
// Largest number of subgroups
n_subgroups_group_max = GBP_MAX(n_subgroups_group_max, n_subgroups_group);
// Count groups
if(n_subgroups_group > 0)
n_groups++;
}
SID_log("Done.", SID_LOG_CLOSE);
}
// Find largest subgroup and count the number of particles in groups
for(i_group = 0, max_subgroup_size = 0, n_particles_in_groups = 0; i_group < n_groups_AHF; i_group++) {
max_subgroup_size = GBP_MAX(max_subgroup_size, subgroup_size[i_group]);
if(subgroup_size[i_group] > 0)
n_particles_in_groups += (size_t)subgroup_size[i_group];
}
// Write some statistics
SID_log("Substructure statistics:", SID_LOG_OPEN);
SID_log("Number of groups =%d", SID_LOG_COMMENT, n_groups);
SID_log("Number of subgroups =%d", SID_LOG_COMMENT, n_subgroups);
SID_log("Max number of subgroups per group=%d", SID_LOG_COMMENT, n_subgroups_group_max);
SID_log("Largest subgroup =%d particles", SID_LOG_COMMENT, subgroup_size_max);
SID_log("Depth of substructure heirarchy =%d levels", SID_LOG_COMMENT, substructure_level_max);
SID_log("Number of AHF particles used =%lld", SID_LOG_COMMENT, n_particles_in_groups);
SID_log("Number of AHF particles NOT used =%lld", SID_LOG_COMMENT, n_particles_AHF_not_used);
SID_log("", SID_LOG_CLOSE | SID_LOG_NOPRINT);
// Open files
SID_set_verbosity(SID_SET_VERBOSITY_RELATIVE, 0);
SID_log("Writing %d groups, %d subgroups and %lld particles to files...",
SID_LOG_OPEN | SID_LOG_TIMER,
n_groups,
n_subgroups,
n_particles_in_groups);
sprintf(filename_out_groups, "%s_%s.catalog_groups", filename_root, filename_number);
sprintf(filename_out_groups_A, "%s_%s.catalog_groups_A", filename_root, filename_number);
sprintf(filename_out_groups_B, "%s_%s.catalog_groups_B", filename_root, filename_number);
sprintf(filename_out_groups_C, "%s_%s.catalog_groups_C", filename_root, filename_number);
sprintf(filename_out_subgroups, "%s_%s.catalog_subgroups", filename_root, filename_number);
sprintf(filename_out_subgroups_A, "%s_%s.catalog_subgroups_A", filename_root, filename_number);
sprintf(filename_out_subgroups_B, "%s_%s.catalog_subgroups_B", filename_root, filename_number);
sprintf(filename_out_hierarchy, "%s_%s.catalog_hierarchy", filename_root, filename_number);
sprintf(filename_out_hierarchy_A, "%s_%s.catalog_hierarchy_A", filename_root, filename_number);
sprintf(filename_out_hierarchy_B, "%s_%s.catalog_hierarchy_B", filename_root, filename_number);
sprintf(filename_out_particles, "%s_%s.catalog_particles", filename_root, filename_number);
fp_out_groups_A = fopen(filename_out_groups_A, "w");
fp_out_groups_B = fopen(filename_out_groups_B, "w");
fp_out_groups_C = fopen(filename_out_groups_C, "w");
fp_out_subgroups_A = fopen(filename_out_subgroups_A, "w");
fp_out_subgroups_B = fopen(filename_out_subgroups_B, "w");
fp_out_hierarchy_A = fopen(filename_out_hierarchy_A, "w");
fp_out_hierarchy_B = fopen(filename_out_hierarchy_B, "w");
fp_out_particles = fopen(filename_out_particles, "w");
// Write headers
fwrite(&n_groups, sizeof(int), 1, fp_out_groups_A);
fwrite(&n_subgroups, sizeof(int), 1, fp_out_subgroups_A);
fwrite(&n_subgroups, sizeof(int), 1, fp_out_hierarchy_A);
fwrite(&id_byte_size, sizeof(int), 1, fp_out_particles);
switch(flag_long_ids) {
case GBP_TRUE:
fwrite(&n_particles_in_groups, sizeof(size_t), 1, fp_out_particles);
break;
default:
n_particles_temp = (int)n_particles_in_groups;
fwrite(&n_particles_temp, sizeof(int), 1, fp_out_particles);
break;
}
// Write files; group and subgroup files in parts (to be concatinated together later)
subgroup_size_list = (int *)SID_malloc(sizeof(int) * n_subgroups_group_max);
subgroup_index_list = (int *)SID_malloc(sizeof(int) * n_subgroups_group_max);
particle_buffer = (void *)SID_malloc(id_byte_size * subgroup_size_max);
subgroup_offset = 0;
group_offset = 0;
for(i_group = n_groups_AHF - 1; i_group >= n_groups_AHF - n_groups; i_group--) {
group_index = group_size_index[i_group];
// Find start of subgroup list for this group
i_subgroup = find_index_int(match_id, group_index, n_groups_AHF, match_id_index);
while(group_index > match_id[match_id_index[i_subgroup]] && i_subgroup < (n_groups_AHF - 2))
i_subgroup++;
if(group_index > match_id[match_id_index[i_subgroup]])
i_subgroup++;
// Create a list of subgroups for this group and sort it by size
n_subgroups_group = 0;
subgroup_index = match_id_index[i_subgroup];
while(match_id[subgroup_index] == group_index && i_subgroup < (n_groups_AHF - 2)) {
if(subgroup_size[subgroup_index] > 0) {
subgroup_size_list[n_subgroups_group] = subgroup_size[subgroup_index];
subgroup_index_list[n_subgroups_group] = (int)subgroup_index;
n_subgroups_group++;
}
i_subgroup++;
subgroup_index = match_id_index[i_subgroup];
}
if(match_id[subgroup_index] == group_index) {
if(subgroup_size[subgroup_index] > 0) {
subgroup_size_list[n_subgroups_group] = subgroup_size[subgroup_index];
subgroup_index_list[n_subgroups_group] = (int)subgroup_index;
n_subgroups_group++;
}
i_subgroup++;
subgroup_index = match_id_index[i_subgroup];
}
merge_sort((void *)subgroup_size_list,
(size_t)n_subgroups_group,
&subgroup_size_list_index,
SID_INT,
SORT_COMPUTE_INDEX,
SORT_COMPUTE_NOT_INPLACE);
// Perform writes for subgroups and particle lists
for(i_subgroup = 0, i_particle = 0; i_subgroup < n_subgroups_group; i_subgroup++) {
j_subgroup = subgroup_index_list[subgroup_size_list_index[n_subgroups_group - i_subgroup - 1]];
// ... subgroups ...
fwrite(&(subgroup_size[j_subgroup]), sizeof(int), 1, fp_out_subgroups_A);
fwrite(&(subgroup_offset), sizeof(int), 1, fp_out_subgroups_B);
fwrite(&(hierarchy_match[j_subgroup]), sizeof(int), 1, fp_out_hierarchy_A);
fwrite(&(hierarchy_level[j_subgroup]), sizeof(int), 1, fp_out_hierarchy_B);
subgroup_offset += subgroup_size[j_subgroup];
// ... and particles
for(j_particle = group_offsets_AHF[j_subgroup], k_particle = 0, i_particle = 0; k_particle < group_size_AHF[j_subgroup];
j_particle++, k_particle++) {
if(particle_group[j_particle] == j_subgroup) {
switch(flag_long_ids) {
case GBP_TRUE:
((size_t *)particle_buffer)[i_particle++] = (size_t)(particle_ids_AHF[j_particle]);
break;
default:
((int *)particle_buffer)[i_particle++] = (int)(particle_ids_AHF[j_particle]);
break;
}
}
}
if(i_particle == subgroup_size[j_subgroup])
fwrite(particle_buffer, id_byte_size, i_particle, fp_out_particles);
else
SID_exit_error("Subgroup size mismatch!", SID_ERROR_LOGIC);
}
SID_free((void **)&subgroup_size_list_index);
// Perform writes for groups
fwrite(&(group_size[group_index]), sizeof(int), 1, fp_out_groups_A);
fwrite(&group_offset, sizeof(int), 1, fp_out_groups_B);
fwrite(&n_subgroups_group, sizeof(int), 1, fp_out_groups_C);
group_offset += group_size[group_index];
}
SID_free((void **)&subgroup_size_list);
SID_free((void **)&subgroup_index_list);
SID_free((void **)&particle_buffer);
fclose(fp_out_groups_A);
fclose(fp_out_groups_B);
fclose(fp_out_groups_C);
fclose(fp_out_subgroups_A);
fclose(fp_out_subgroups_B);
fclose(fp_out_hierarchy_A);
fclose(fp_out_hierarchy_B);
fclose(fp_out_particles);
// Concatinate group and subgroup temp files into final files
SID_cat_files(filename_out_groups, SID_CAT_CLEAN, 3, filename_out_groups_A, filename_out_groups_B, filename_out_groups_C);
SID_cat_files(filename_out_subgroups, SID_CAT_CLEAN, 2, filename_out_subgroups_A, filename_out_subgroups_B);
SID_cat_files(filename_out_hierarchy, SID_CAT_CLEAN, 2, filename_out_hierarchy_A, filename_out_hierarchy_B);
// Clean-up
SID_free((void **)&subgroup_size);
SID_free((void **)&hierarchy_level);
SID_free((void **)&group_size);
SID_free((void **)&group_size_index);
SID_free((void **)&match_id_index);
free_plist(&plist);
SID_set_verbosity(SID_SET_VERBOSITY_DEFAULT);
SID_log("Done.", SID_LOG_CLOSE);
// Write log file
SID_log("Writing to log file...", SID_LOG_OPEN);
// Write a header for the log file
if(i_file == i_file_start) {
fp_log = fopen(filename_log, "w");
fprintf(fp_log, "# (1): filenumber\n");
fprintf(fp_log, "# (2): n_groups_AHF\n");
fprintf(fp_log, "# (3): n_particles_AHF\n");
fprintf(fp_log, "# (4): n_groups\n");
fprintf(fp_log, "# (5): n_subgroups\n");
fprintf(fp_log, "# (6): max number of subgroups per group\n");
fprintf(fp_log, "# (7): largest subgroup\n");
fprintf(fp_log, "# (8): depth of substructure heirarchy\n");
fprintf(fp_log, "# (9): number of AHF particles used\n");
fprintf(fp_log, "# (10): number of AHF particles NOT used\n");
} else
fp_log = fopen(filename_log, "a");
fprintf(fp_log,
"%4d %9d %12zd %9d %9d %9d %9d %9d %12zd %12zd\n",
i_file,
n_groups_AHF,
n_particles_AHF,
n_groups,
n_subgroups,
n_subgroups_group_max,
subgroup_size_max,
substructure_level_max,
n_particles_in_groups,
n_particles_AHF_not_used);
fclose(fp_log);
SID_log("Done.", SID_LOG_CLOSE);
SID_log("Done.", SID_LOG_CLOSE);
}
SID_log("Done.", SID_LOG_CLOSE);
SID_Finalize();
}
void init_gbpCosmo2gbpCosmo(cosmo_info **cosmo_source,
cosmo_info **cosmo_target,
double z_min,
double M_min,
double M_max,
gbpCosmo2gbpCosmo_info *gbpCosmo2gbpCosmo){
SID_log("Initializing cosmology scaling...",SID_LOG_OPEN|SID_LOG_TIMER);
SID_set_verbosity(SID_SET_VERBOSITY_RELATIVE,-1);
// Store some infor in the gbpCosmo2gbpCosmo_info structure
gbpCosmo2gbpCosmo->M_min =M_min;
gbpCosmo2gbpCosmo->M_max =M_max;
gbpCosmo2gbpCosmo->z_min =z_min;
gbpCosmo2gbpCosmo->cosmo_source=(*cosmo_source);
gbpCosmo2gbpCosmo->cosmo_target=(*cosmo_target);
// Perform minimization
//const gsl_multimin_fminimizer_type *T=gsl_multimin_fminimizer_nmsimplex2;
const gsl_multimin_fminimizer_type *T=gsl_multimin_fminimizer_nmsimplex;
gsl_multimin_fminimizer *s = NULL;
gsl_vector *ss, *x;
gsl_multimin_function minex_func;
// Starting point
x = gsl_vector_alloc (2);
gsl_vector_set (x, 0, 1.); // inv_s
gsl_vector_set (x, 1, z_min); // z_scaled
// Set initial step sizes to 1
ss = gsl_vector_alloc (2);
gsl_vector_set_all (ss, 1.0);
// Set parameters
init_gbpCosmo2gbpCosmo_integrand_params params;
params.cosmo_source=cosmo_source;
params.cosmo_target=cosmo_target;
params.z_source =z_min;
params.R_1 =R_of_M(M_min,*cosmo_source);
params.R_2 =R_of_M(M_max,*cosmo_source);
params.inv_s =gsl_vector_get(x,0);
params.z_target =gsl_vector_get(x,1);
params.n_int =100;
params.wspace =gsl_integration_workspace_alloc(params.n_int);
// Initialize method
minex_func.n = 2;
minex_func.f = init_gbpCosmo2gbpCosmo_minimize_function;
minex_func.params = (void *)(¶ms);
s = gsl_multimin_fminimizer_alloc (T, 2);
gsl_multimin_fminimizer_set(s,&minex_func,x,ss);
// Perform minimization
double size;
int status;
size_t iter = 0;
size_t iter_max=200;
do{
iter++;
status=gsl_multimin_fminimizer_iterate(s);
if(status)
SID_trap_error("Error encountered during minimisation in init_gbpCosmo2gbpCosmo() (status=%d).",ERROR_LOGIC,status);
size = gsl_multimin_fminimizer_size(s);
status = gsl_multimin_test_size(size,1e-2);
} while(status==GSL_CONTINUE && iter<=iter_max);
if(status!=GSL_SUCCESS)
SID_trap_error("Failed to converge during minimisation in init_gbpCosmo2gbpCosmo() (status=%d,iter=%d).",ERROR_LOGIC,status,iter);
// Finalize results
double Omega_M_source = ((double *)ADaPS_fetch(*cosmo_source,"Omega_M") )[0];
double H_Hubble_source=1e2*((double *)ADaPS_fetch(*cosmo_source,"h_Hubble"))[0];
double Omega_M_target = ((double *)ADaPS_fetch(*cosmo_target,"Omega_M") )[0];
double H_Hubble_target=1e2*((double *)ADaPS_fetch(*cosmo_target,"h_Hubble"))[0];
gbpCosmo2gbpCosmo->s_L =1./gsl_vector_get(s->x,0);
gbpCosmo2gbpCosmo->s_M =(Omega_M_target*H_Hubble_target)/(Omega_M_source*H_Hubble_source)*pow((gbpCosmo2gbpCosmo->s_L),3.);
gbpCosmo2gbpCosmo->z_min_scaled=gsl_vector_get(s->x,1);;
// Calculate growth factors needed for
// determining redshift mappings
gbpCosmo2gbpCosmo->D_prime_z_min=linear_growth_factor(z_min, *cosmo_target);
gbpCosmo2gbpCosmo->D_z_scaled =linear_growth_factor(gbpCosmo2gbpCosmo->z_min_scaled,*cosmo_source);
gbpCosmo2gbpCosmo->D_ratio =gbpCosmo2gbpCosmo->D_prime_z_min/gbpCosmo2gbpCosmo->D_z_scaled;
// Clean-up
gsl_vector_free(x);
gsl_vector_free(ss);
gsl_multimin_fminimizer_free(s);
gsl_integration_workspace_free(params.wspace);
SID_set_verbosity(SID_SET_VERBOSITY_DEFAULT);
SID_log("Done.",SID_LOG_CLOSE);
}
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);
// 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();
}
