void init_trees_data(tree_info *trees, void ***rval, size_t data_size, int mode, const char *name, ...){ va_list vargs; va_start(vargs,name); // Create the new item (and apply some defaults) ADaPS *new_item; store_tree_data_free_parms_info *params; params =(store_tree_data_free_parms_info *)SID_malloc(sizeof(store_tree_data_free_parms_info)); params->n_snaps =trees->n_snaps; new_item =(ADaPS *)SID_malloc(sizeof(ADaPS)); new_item->mode =ADaPS_CUSTOM; new_item->free_function =free_trees_data; new_item->free_function_params=params; // Determine the size of the allocation new_item->data_size=trees->n_snaps*sizeof(void *); // Allocate arrays new_item->data=SID_malloc(sizeof(void *)*trees->n_snaps); void **data=(void **)new_item->data; for(int i_snap=0;i_snap<trees->n_snaps;i_snap++){ size_t n_items; size_t alloc_size; if(mode==INIT_TREE_DATA_GROUPS) n_items=trees->n_groups_snap_local[i_snap]; else if(mode==INIT_TREE_DATA_SUBGROUPS) n_items=trees->n_subgroups_snap_local[i_snap]; else SID_trap_error("Invalid init_tree_data() mode (%d).",ERROR_LOGIC,mode); alloc_size =data_size*n_items; data[i_snap] =SID_malloc(alloc_size); // Returns NULL if alloc_size==0 new_item->data_size+=alloc_size; } // Give the new item its name vsprintf(new_item->name,name,vargs); // Remove any previous entries with this name ADaPS_remove(&(trees->data),new_item->name); // Place new item at the start of the list new_item->next=trees->data; trees->data =new_item; (*rval)=data; va_end(vargs); }
void swap_endian_grids(const char *filename_in,const char *filename_out,int mode){ SID_log("Swapping endian of grids...",SID_LOG_OPEN); // Sanity check if(check_mode_for_flag(mode,SWAP_SSIMPL_ENDIAN_FROM_NATIVE) && check_mode_for_flag(mode,SWAP_SSIMPL_ENDIAN_FROM_NATIVE)) SID_trap_error("Invalid mode flag (%d) in swap_endian_grids().",ERROR_LOGIC,mode); // Open input and output files FILE *fp_in =NULL; FILE *fp_out=NULL; if((fp_in=fopen(filename_in,"r"))==NULL) SID_log("not present.",SID_LOG_CLOSE,filename_in); else{ if((fp_out=fopen(filename_out,"w"))==NULL) SID_trap_error("Could not open {%s} for writing.",ERROR_IO_OPEN,filename_out); // Read the needed header information and rewind int n[3]; double L[3]; int n_grids; int scheme; fread_verify(&(n[0]), sizeof(int), 1,fp_in); fread_verify(&(n[1]), sizeof(int), 1,fp_in); fread_verify(&(n[2]), sizeof(int), 1,fp_in); fread_verify(&(L[0]), sizeof(double),1,fp_in); fread_verify(&(L[1]), sizeof(double),1,fp_in); fread_verify(&(L[2]), sizeof(double),1,fp_in); fread_verify(&n_grids,sizeof(int), 1,fp_in); fread_verify(&scheme, sizeof(int), 1,fp_in); if(check_mode_for_flag(mode,SWAP_SSIMPL_ENDIAN_TO_NATIVE)){ swap_endian((char *)(n), 3,sizeof(int)); swap_endian((char *)(&n_grids),1,sizeof(int)); } int grid_size=n[0]*n[1]*n[2]; rewind(fp_in); // Create a read buffer char *buffer=(char *)SID_malloc(sizeof(char)*grid_size*sizeof(fftw_real)); // Process the file rewrite_swap_endian(fp_in,fp_out,3,sizeof(int), buffer); rewrite_swap_endian(fp_in,fp_out,3,sizeof(double),buffer); rewrite_swap_endian(fp_in,fp_out,2,sizeof(int), buffer); for(int i_grid=0;i_grid<n_grids;i_grid++){ rewrite_swap_endian(fp_in,fp_out,GRID_IDENTIFIER_SIZE,sizeof(char), buffer); rewrite_swap_endian(fp_in,fp_out,grid_size, sizeof(fftw_real),buffer); } // Free the read buffer SID_free(SID_FARG buffer); // Close files fclose(fp_in); fclose(fp_out); SID_log("Done.",SID_LOG_CLOSE); } }
void swap_endian_halos_subgroups_local(const char *filename_in_root, const char *filename_out_root, const char *filename_halo_type, int snap_number, int mode) { SID_log("Swapping endian of subgroup file...", SID_LOG_OPEN); // Sanity check if(SID_CHECK_BITFIELD_SWITCH(mode, SWAP_SSIMPL_ENDIAN_FROM_NATIVE) && SID_CHECK_BITFIELD_SWITCH(mode, SWAP_SSIMPL_ENDIAN_FROM_NATIVE)) SID_exit_error("Invalid mode flag (%d) in swap_endian_halos_subgroups_local().", SID_ERROR_LOGIC, mode); // Set filenames char filename_in[SID_MAX_FILENAME_LENGTH]; char filename_out[SID_MAX_FILENAME_LENGTH]; sprintf(filename_in, "%s/%s_%03d.catalog_subgroups", filename_in_root, filename_halo_type, snap_number); sprintf(filename_out, "%s/%s_%03d.catalog_subgroups", filename_out_root, filename_halo_type, snap_number); // Open input and output files FILE *fp_in = NULL; FILE *fp_out = NULL; if((fp_in = fopen(filename_in, "r")) == NULL) SID_exit_error("Could not open {%s} for reading.", SID_ERROR_IO_OPEN, filename_in); if((fp_out = fopen(filename_out, "w")) == NULL) SID_exit_error("Could not open {%s} for writing.", SID_ERROR_IO_OPEN, filename_out); // Read the needed header information and rewind int n_subgroups; int offset_size_bytes; SID_fread_verify(&n_subgroups, sizeof(int), 1, fp_in); SID_fread_verify(&offset_size_bytes, sizeof(int), 1, fp_in); if(SID_CHECK_BITFIELD_SWITCH(mode, SWAP_SSIMPL_ENDIAN_TO_NATIVE)) { swap_endian((char *)(&n_subgroups), 1, sizeof(int)); swap_endian((char *)(&offset_size_bytes), 1, sizeof(int)); } rewind(fp_in); // Create a read buffer char *buffer = (char *)SID_malloc(sizeof(char) * offset_size_bytes); // Process the file rewrite_swap_endian(fp_in, fp_out, 2, sizeof(int), buffer); for(int i_subgroup = 0; i_subgroup < n_subgroups; i_subgroup++) rewrite_swap_endian(fp_in, fp_out, 1, sizeof(int), buffer); for(int i_subgroup = 0; i_subgroup < n_subgroups; i_subgroup++) rewrite_swap_endian(fp_in, fp_out, 1, offset_size_bytes, buffer); for(int i_subgroup = 0; i_subgroup < n_subgroups; i_subgroup++) rewrite_swap_endian(fp_in, fp_out, 1, sizeof(int), buffer); // Free the read buffer SID_free(SID_FARG buffer); // Close files fclose(fp_in); fclose(fp_out); SID_log("Done.", SID_LOG_CLOSE); }
double bias_model_BPR_integral(cosmo_info **cosmo, double z) { double z_max = 10000.; interp_info *interp; if(!ADaPS_exist(*cosmo, "bias_model_BPR_Iz_interp")) { int n_int; int i_int; double dz; double Omega_M, Omega_k, Omega_Lambda; double z_temp; double *x_int; double *y_int; double log_z; double dlog_z; n_int = 250; Omega_M = ((double *)ADaPS_fetch(*cosmo, "Omega_M"))[0]; Omega_k = ((double *)ADaPS_fetch(*cosmo, "Omega_k"))[0]; Omega_Lambda = ((double *)ADaPS_fetch(*cosmo, "Omega_Lambda"))[0]; x_int = (double *)SID_malloc(sizeof(double) * n_int); y_int = (double *)SID_malloc(sizeof(double) * n_int); i_int = 0; x_int[i_int] = 0.; y_int[i_int] = pow((1. + x_int[i_int]) / E_z(Omega_M, Omega_k, Omega_Lambda, x_int[i_int]), 3.); i_int++; x_int[i_int] = take_log10(z_max) / (double)(n_int - 1); y_int[i_int] = pow((1. + x_int[i_int]) / E_z(Omega_M, Omega_k, Omega_Lambda, x_int[i_int]), 3.); log_z = take_log10(x_int[i_int]); dlog_z = (take_log10(z_max) - log_z) / (double)(n_int - 2); for(i_int++, log_z += dlog_z; i_int < (n_int - 1); i_int++, log_z += dlog_z) { x_int[i_int] = take_alog10(log_z); y_int[i_int] = pow((1. + x_int[i_int]) / E_z(Omega_M, Omega_k, Omega_Lambda, x_int[i_int]), 3.); } x_int[i_int] = z_max; y_int[i_int] = pow((1. + x_int[i_int]) / E_z(Omega_M, Omega_k, Omega_Lambda, x_int[i_int]), 3.); init_interpolate(x_int, y_int, (size_t)n_int, gsl_interp_cspline, &interp); SID_free(SID_FARG x_int); SID_free(SID_FARG y_int); ADaPS_store_interp(cosmo, (void *)(interp), "bias_model_BPR_Iz_interp"); } else interp = (interp_info *)ADaPS_fetch(*cosmo, "bias_model_BPR_Iz_interp"); return (interpolate_integral(interp, z, z_max)); }
void init_tree_property_tau(trend_property_info *property, void *trees_in, int i_hist, int *mode, gbp_va_list *vargs) { (*mode) = GBP_HISTOGRAM_IRREGULAR_XLO_DEFINED; tree_info *trees = (tree_info *)trees_in; double * tau_array = (double *)SID_malloc(sizeof(double) * trees->n_snaps); int n_bins; int i_0; if(property->is_ordinate) { n_bins = trees->n_snaps; i_0 = trees->n_snaps - 1; } else { n_bins = GBP_MIN(i_hist + 1, trees->n_snaps); i_0 = i_hist; } SID_va_start(vargs); SID_add_va_arg(vargs, sizeof(double), &tau_array); SID_add_va_arg(vargs, sizeof(int), &n_bins); for(int i_tau = 0; i_tau < n_bins; i_tau++) tau_array[i_tau] = (trees->t_list[i_0] - trees->t_list[i_0 - i_tau]) / t_dyn_z(trees->z_list[i_0], trees->cosmo); }
void set_MCMC_covariance(MCMC_info *MCMC, double *V) { int i_P, j_P; if(V == NULL) SID_log("Initializing the covariance matrix...", SID_LOG_OPEN); else SID_log("Updating the covariance matrix...", SID_LOG_OPEN); if(MCMC->V == NULL) MCMC->V = (double *)SID_malloc(sizeof(double) * MCMC->n_P * MCMC->n_P); if(MCMC->m == NULL) MCMC->m = gsl_matrix_calloc(MCMC->n_P, MCMC->n_P); if(MCMC->b == NULL) MCMC->b = gsl_vector_calloc(MCMC->n_P); if(V == NULL) { for(i_P = 0; i_P < MCMC->n_P; i_P++) { for(j_P = 0; j_P < MCMC->n_P; j_P++) { if(i_P == j_P) { // Matrix decomposition fails if we initialize an element to zero here. // Check for this and start with an different value if true. if(MCMC->P_init[i_P] == 0.) MCMC->V[i_P * MCMC->n_P + j_P] = 1e-3 * MCMC->P_limit_max[i_P]; else MCMC->V[i_P * MCMC->n_P + j_P] = pow(MCMC->P_init[i_P], 2.); } else MCMC->V[i_P * MCMC->n_P + j_P] = 0.; } } } else memcpy(MCMC->V, V, (size_t)(MCMC->n_P * MCMC->n_P) * sizeof(double)); for(i_P = 0; i_P < MCMC->n_P; i_P++) for(j_P = 0; j_P < MCMC->n_P; j_P++) gsl_matrix_set(MCMC->m, i_P, j_P, MCMC->V[i_P * MCMC->n_P + j_P]); gsl_linalg_cholesky_decomp(MCMC->m); // Set the upper-diagonal to zero to get L where covariance=L*L^T for(i_P = 0; i_P < MCMC->n_P; i_P++) for(j_P = i_P + 1; j_P < MCMC->n_P; j_P++) gsl_matrix_set(MCMC->m, i_P, j_P, 0.); SID_log("Done.", SID_LOG_CLOSE); }
void init_image(int width, int height, const char *colourmapselect, image_info **image) { int i_pixel; // Allocate image (*image) = (image_info *)SID_malloc(sizeof(image_info)); // Set image specs (*image)->width = width; (*image)->height = height; (*image)->n_pixels = width * height; // Init gdlib stuff (*image)->gd_ptr = gdImageCreateTrueColor((*image)->width, (*image)->height); // Allocate image buffers (*image)->values = (double *)malloc(sizeof(double) * (*image)->n_pixels); for(i_pixel = 0; i_pixel < (*image)->n_pixels; i_pixel++) (*image)->values[i_pixel] = 0.; // Set colourtable strcpy((*image)->colourmapselect, colourmapselect); create_colour_table(colourmapselect, &((*image)->n_colours), &((*image)->colour_table)); }
void read_mark_file(plist_info *plist, const char *mark_name, const char *filename_in, int mode){ int i_species; size_t i_particle; size_t j_particle; size_t k_particle; int i_rank; size_t i_mark; size_t n_particles_local; size_t *mark_list_buffer; int *mark_list; size_t *ids_local; size_t *mark_list_local; size_t n_mark_total; size_t n_mark_total_check; size_t n_mark_type_local[N_GADGET_TYPE]; size_t n_mark_local; size_t n_particle_local; SID_fp fp_mark_file; size_t i_start_local[N_GADGET_TYPE]; size_t n_mark_bcast; size_t *ids_local_index; size_t n_buffer; int flag_allocate; int flag_read_mode; int flag_mark_mode; int flag_op_mode; markfile_header_info header={N_GADGET_TYPE}; SID_log("Reading mark file...",SID_LOG_OPEN); // Interpret run mode if(check_mode_for_flag(mode,MARK_READ_ALL)) flag_read_mode=MARK_READ_ALL; else flag_read_mode=MARK_DEFAULT; if(check_mode_for_flag(mode,MARK_LIST_ONLY)) flag_mark_mode=MARK_LIST_ONLY; else flag_mark_mode=MARK_DEFAULT; if(check_mode_for_flag(mode,MARK_INIT) || check_mode_for_flag(mode,MARK_OR)) flag_op_mode=MARK_DEFAULT; else flag_op_mode=MARK_AND; // Open mark list and read header SID_fopen_chunked(filename_in, "r", &fp_mark_file, &header); if(header.n_type!=N_GADGET_TYPE) SID_trap_error("Inconsistant number of species in mark file (ie. %d!=%d)!",ERROR_LOGIC,header.n_type,N_GADGET_TYPE); // List numbers of particles in the log output size_t n_particles_all; int n_non_zero; for(i_species=0,n_particles_all=0,n_non_zero=0;i_species<header.n_type;i_species++){ if(header.n_mark_species[i_species]>0){ n_particles_all+=header.n_mark_species[i_species]; n_non_zero++; } } SID_log("%lld",SID_LOG_CONTINUE,n_particles_all); if(n_non_zero>0) SID_log(" (",SID_LOG_CONTINUE,n_particles_all); for(i_species=0;i_species<N_GADGET_TYPE;i_species++){ if(header.n_mark_species[i_species]>0){ if(i_species==n_non_zero-1){ if(n_non_zero>1) SID_log("and %lld %s",SID_LOG_CONTINUE,header.n_mark_species[i_species],plist->species[i_species]); else SID_log("%lld %s",SID_LOG_CONTINUE,header.n_mark_species[i_species],plist->species[i_species]); } else{ if(n_non_zero>1) SID_log("%lld %s, ",SID_LOG_CONTINUE,header.n_mark_species[i_species],plist->species[i_species]); else SID_log("%lld %s",SID_LOG_CONTINUE,header.n_mark_species[i_species],plist->species[i_species]); } } } if(n_non_zero>0) SID_log(") particles...",SID_LOG_CONTINUE); else SID_log(" particles...",SID_LOG_CONTINUE); // Set list sizes and prep offsets for reading for(i_species=0,n_mark_local=0,n_mark_total_check=0;i_species<header.n_type;i_species++){ if(header.n_mark_species[i_species]>0){ ADaPS_store(&(plist->data),(void *)(&(header.n_mark_species[i_species])),"n_%s_%s",ADaPS_SCALAR_SIZE_T,mark_name,plist->species[i_species]); switch(flag_read_mode){ case MARK_READ_ALL: n_mark_type_local[i_species]=header.n_mark_species[i_species]; i_start_local[i_species] =0; break; default: n_mark_type_local[i_species]=header.n_mark_species[i_species]/SID.n_proc; i_start_local[i_species] =(SID.My_rank)*n_mark_type_local[i_species]; if(SID.I_am_last_rank) n_mark_type_local[i_species]=header.n_mark_species[i_species]-i_start_local[i_species]; break; } ADaPS_store(&(plist->data),(void *)(&(n_mark_type_local[i_species])),"n_local_%s_%s",ADaPS_SCALAR_SIZE_T,mark_name,plist->species[i_species]); n_mark_local +=n_mark_type_local[i_species]; n_mark_total_check+=header.n_mark_species[i_species]; } } // Sanity check SID_Allreduce(&n_mark_local,&n_mark_total,1,SID_SIZE_T,SID_SUM,SID.COMM_WORLD); if(n_mark_total!=n_mark_total_check) SID_trap_error("Particle numbers don't add-up right in read_mark_file!",ERROR_LOGIC); // Read file and create/store mark arrays switch(flag_mark_mode){ case MARK_LIST_ONLY: for(i_species=0;i_species<header.n_type;i_species++){ if(header.n_mark_species[i_species]>0){ // Allocate array if(n_mark_type_local[i_species]>0) mark_list_local=(size_t *)SID_malloc(sizeof(size_t)*n_mark_type_local[i_species]); else mark_list_local=NULL; // Perform read SID_fread_chunked(mark_list_local, n_mark_type_local[i_species], i_start_local[i_species], &fp_mark_file); // Sort marked particles if(n_mark_type_local[i_species]>0){ merge_sort(mark_list_local,n_mark_type_local[i_species],NULL,SID_SIZE_T,SORT_INPLACE_ONLY,SORT_COMPUTE_INPLACE); ADaPS_store(&(plist->data),(void *)(mark_list_local),"%s_%s",ADaPS_DEFAULT,mark_name,plist->species[i_species]); } } } break; default: mark_list_buffer=(size_t *)SID_malloc(sizeof(size_t)*MAX_MARK_BUFFER_SIZE); for(i_species=0;i_species<header.n_type;i_species++){ if(header.n_mark_species[i_species]>0){ n_particles_local=((size_t *)ADaPS_fetch(plist->data,"n_%s",plist->species[i_species]))[0]; // Initialize arrays ids_local=(size_t *)ADaPS_fetch(plist->data,"id_%s",plist->species[i_species]); if(ADaPS_exist(plist->data,"%s_%s",mark_name,plist->species[i_species])){ mark_list=(int *)ADaPS_fetch(plist->data,"%s_%s",mark_name,plist->species[i_species]); flag_allocate=FALSE; } else{ mark_list=(int *)SID_malloc(sizeof(int)*n_particles_local); for(i_particle=0;i_particle<n_particles_local;i_particle++) mark_list[i_particle]=FALSE; flag_allocate=TRUE; } merge_sort(ids_local,n_particles_local,&ids_local_index,SID_SIZE_T,SORT_COMPUTE_INDEX,SORT_COMPUTE_NOT_INPLACE); // Use a buffer to increase speed for(i_particle=0;i_particle<header.n_mark_species[i_species];){ n_buffer=MIN(header.n_mark_species[i_species]-i_particle,MAX_MARK_BUFFER_SIZE); SID_fread_chunked_all(mark_list_local, n_buffer, &fp_mark_file); merge_sort(mark_list_local,n_buffer,NULL,SID_SIZE_T,SORT_INPLACE_ONLY,SORT_COMPUTE_INPLACE); for(j_particle=0,k_particle=find_index(ids_local,mark_list_buffer[0],n_particles_local,ids_local_index); j_particle<n_buffer; j_particle++,i_particle++){ while(ids_local[ids_local_index[k_particle]]<mark_list_local[j_particle] && k_particle<n_buffer-1) k_particle++; if(ids_local[ids_local_index[k_particle]]==mark_list_local[j_particle]){ switch(flag_op_mode){ case MARK_INIT: case MARK_AND: case MARK_OR: mark_list[i_particle]=TRUE; break; } } } } SID_free((void **)&ids_local_index); ADaPS_store(&(plist->data),(void *)mark_list,"%s_%s",ADaPS_DEFAULT,mark_name,plist->species[i_species]); } } SID_free((void **)&mark_list_buffer); break; } SID_fclose_chunked(&fp_mark_file); SID_log("Done.",SID_LOG_CLOSE); }
int main(int argc, char *argv[]) { plist_info plist; char filename_PHKs_root[256]; char filename_snapshot_root[256]; char filename_snapshot[256]; char filename_output_properties_dir[256]; char filename_output_properties[256]; char filename_output_profiles_dir[256]; char filename_output_profiles[256]; char filename_output_SO_dir[256]; char filename_output_SO[256]; char filename_output_properties_temp[256]; char filename_output_profiles_temp[256]; char filename_output_SO_temp[256]; char group_text_prefix[4]; int n_groups_process; int n_groups; int n_groups_all; int i_rank; int i_group; int i_file_lo_in; int i_file_lo; int i_file_hi_in; int i_file_hi; int i_file; int i_file_skip; int i_particle; int j_particle; int i_process; int n_particles; int n_particles_max; size_t n_particles_cumulative; GBPREAL * x_array; GBPREAL * y_array; GBPREAL * z_array; size_t * ids_particles; size_t * ids_particles_index; size_t * ids_groups; int * n_particles_groups_process; int * n_particles_groups; int * n_particles_subgroups; int * group_offset; size_t n_particles_in_groups; size_t * ids_snapshot; size_t * ids_sort_index; size_t * ids_snapshot_sort_index; size_t * ids_groups_sort_index; size_t n_particles_snapshot; int i_value; double h_Hubble; double Omega_M; double Omega_b; double Omega_Lambda; double f_gas; double Omega_k; double sigma_8; double n_spec; double redshift; double particle_mass; int r_val; struct stat file_stats; size_t n_bytes; size_t n_bytes_buffer; void * buffer; FILE * fp_PHKs; FILE * fp_profiles; FILE * fp_PHKs_temp; FILE * fp_profiles_temp; cosmo_info * cosmo; halo_properties_info properties; halo_profile_info profile; int n_temp; int n_truncated; int largest_truncated; int largest_truncated_local; char * filename_number; SID_Init(&argc, &argv, NULL); // Fetch user inputs char filename_in_root[SID_MAX_FILENAME_LENGTH]; char filename_out_root[SID_MAX_FILENAME_LENGTH]; char filename_properties_in[SID_MAX_FILENAME_LENGTH]; char filename_properties_out[SID_MAX_FILENAME_LENGTH]; char filename_profiles_in[SID_MAX_FILENAME_LENGTH]; char filename_profiles_out[SID_MAX_FILENAME_LENGTH]; char filename_SO_in[SID_MAX_FILENAME_LENGTH]; char filename_SO_out[SID_MAX_FILENAME_LENGTH]; strcpy(filename_in_root, argv[1]); strcpy(filename_out_root, argv[2]); int start_snap = atoi(argv[3]); int stop_snap = atoi(argv[4]); int n_files_out_in = atoi(argv[5]); // Process each snapshot in turn SID_log("Rewriting catalogs from root {%s} to root {%s} with %d files...", SID_LOG_OPEN, filename_in_root, filename_out_root, n_files_out_in); for(int i_snap = start_snap; i_snap <= stop_snap; i_snap++) { SID_log("Processing snapshot No. %d...", SID_LOG_OPEN | SID_LOG_TIMER, i_snap); // Loop once for subgroups and once for groups for(int i_run = 0; i_run < 2; i_run++) { char filename_in[SID_MAX_FILENAME_LENGTH]; char filename_out[SID_MAX_FILENAME_LENGTH]; char group_prefix_text[8]; switch(i_run) { case 0: sprintf(group_prefix_text, "sub"); break; case 1: sprintf(group_prefix_text, ""); break; } SID_log("Processing %sgroups...", SID_LOG_OPEN | SID_LOG_TIMER, group_prefix_text); sprintf(filename_properties_in, "%s_%03d.catalog_%sgroups_properties", filename_in_root, i_snap, group_prefix_text); sprintf(filename_properties_out, "%s_%03d.catalog_%sgroups_properties", filename_out_root, i_snap, group_prefix_text); sprintf(filename_profiles_in, "%s_%03d.catalog_%sgroups_profiles", filename_in_root, i_snap, group_prefix_text); sprintf(filename_profiles_out, "%s_%03d.catalog_%sgroups_profiles", filename_out_root, i_snap, group_prefix_text); sprintf(filename_SO_in, "%s_%03d.catalog_%sgroups_SO", filename_in_root, i_snap, group_prefix_text); sprintf(filename_SO_out, "%s_%03d.catalog_%sgroups_SO", filename_out_root, i_snap, group_prefix_text); // Create filename bases for each dataset char filename_properties_in_base[SID_MAX_FILENAME_LENGTH]; char filename_properties_out_base[SID_MAX_FILENAME_LENGTH]; char filename_profiles_in_base[SID_MAX_FILENAME_LENGTH]; char filename_profiles_out_base[SID_MAX_FILENAME_LENGTH]; char filename_SO_in_base[SID_MAX_FILENAME_LENGTH]; char filename_SO_out_base[SID_MAX_FILENAME_LENGTH]; strcpy(filename_properties_in_base, filename_properties_in); strcpy(filename_properties_out_base, filename_properties_out); strcpy(filename_profiles_in_base, filename_profiles_in); strcpy(filename_profiles_out_base, filename_profiles_out); strcpy(filename_SO_in_base, filename_SO_in); strcpy(filename_SO_out_base, filename_SO_out); strip_path(filename_properties_in_base); strip_path(filename_properties_out_base); strip_path(filename_profiles_in_base); strip_path(filename_profiles_out_base); strip_path(filename_SO_in_base); strip_path(filename_SO_out_base); // Figure out if the properties file(s) are multi-file format int i_file; int n_files_props; int n_props; int n_props_all; int flag_multifile_properties = GBP_FALSE; FILE *fp_test; char filename_test[SID_MAX_FILENAME_LENGTH]; sprintf(filename_test, "%s/%s.0", filename_properties_in, filename_properties_in_base); if((fp_test = fopen(filename_test, "r")) != NULL) { SID_fread_verify(&i_file, sizeof(int), 1, fp_test); SID_fread_verify(&n_files_props, sizeof(int), 1, fp_test); SID_fread_verify(&n_props, sizeof(int), 1, fp_test); SID_fread_verify(&n_props_all, sizeof(int), 1, fp_test); fclose(fp_test); flag_multifile_properties = GBP_TRUE; } else { sprintf(filename_test, "%s", filename_properties_in); if((fp_test = fopen(filename_test, "r")) != NULL) { SID_fread_verify(&i_file, sizeof(int), 1, fp_test); SID_fread_verify(&n_files_props, sizeof(int), 1, fp_test); SID_fread_verify(&n_props, sizeof(int), 1, fp_test); SID_fread_verify(&n_props_all, sizeof(int), 1, fp_test); fclose(fp_test); flag_multifile_properties = GBP_FALSE; if(n_props != n_props_all) SID_exit_error("Halo counts don't agree (ie. %d!=%d) in properties file.", SID_ERROR_LOGIC, n_props, n_props_all); if(n_files_props != 1) SID_exit_error("Invalid file count (%d) in non-multifile properties file {%s}.", SID_ERROR_LOGIC, n_files_props, filename_test); } else SID_exit_error("Could not open properties dataset.", SID_ERROR_IO_OPEN); } if(i_file != 0) SID_exit_error("Invalid starting file index (%d) in properties file.", SID_ERROR_LOGIC, i_file); // Figure out if the profiles file(s) are multi-file format int n_files_profs; int n_profs; int n_profs_all; int flag_multifile_profiles = GBP_FALSE; sprintf(filename_test, "%s/%s.0", filename_profiles_in, filename_profiles_in_base); if((fp_test = fopen(filename_test, "r")) != NULL) { int i_file; SID_fread_verify(&i_file, sizeof(int), 1, fp_test); SID_fread_verify(&n_files_profs, sizeof(int), 1, fp_test); SID_fread_verify(&n_profs, sizeof(int), 1, fp_test); SID_fread_verify(&n_profs_all, sizeof(int), 1, fp_test); fclose(fp_test); flag_multifile_profiles = GBP_TRUE; } else { sprintf(filename_test, "%s", filename_profiles_in); if((fp_test = fopen(filename_test, "r")) != NULL) { SID_fread_verify(&i_file, sizeof(int), 1, fp_test); SID_fread_verify(&n_files_profs, sizeof(int), 1, fp_test); SID_fread_verify(&n_profs, sizeof(int), 1, fp_test); SID_fread_verify(&n_profs_all, sizeof(int), 1, fp_test); fclose(fp_test); flag_multifile_profiles = GBP_FALSE; if(n_profs != n_profs_all) SID_exit_error("Halo counts don't agree (ie. %d!=%d) in profiles file.", SID_ERROR_LOGIC, n_profs, n_profs_all); if(n_files_profs != 1) SID_exit_error("Invalid file count (%d) in non-multifile profiles file.", SID_ERROR_LOGIC, n_files_profs); } else SID_exit_error("Could not open profiles dataset.", SID_ERROR_IO_OPEN); } if(i_file != 0) SID_exit_error("Invalid starting file index (%d) in profiles file.", SID_ERROR_LOGIC, i_file); // Check that the halo counts in the properties and profiles datasets agree if(n_profs_all != n_props_all) SID_exit_error("The properties and profiles halo counts don't agree (ie. %d!=%d)", SID_ERROR_LOGIC, n_profs_all, n_props_all); int n_halos_all = n_props_all; SID_log("(%d halos)...", SID_LOG_CONTINUE, n_halos_all); // SO files are defined only for groups int n_files_SO; int n_SO; int n_SO_all; int flag_multifile_SO = GBP_FALSE; int flag_SO_present = GBP_TRUE; if(i_run == 1) { // Figure out if the SO file(s) are multi-file format sprintf(filename_test, "%s/%s.0", filename_SO_in, filename_SO_in_base); if((fp_test = fopen(filename_test, "r")) != NULL) { int i_file; SID_fread_verify(&i_file, sizeof(int), 1, fp_test); SID_fread_verify(&n_files_SO, sizeof(int), 1, fp_test); SID_fread_verify(&n_SO, sizeof(int), 1, fp_test); SID_fread_verify(&n_SO_all, sizeof(int), 1, fp_test); fclose(fp_test); flag_multifile_SO = GBP_TRUE; } else { sprintf(filename_test, "%s", filename_SO_in); if((fp_test = fopen(filename_test, "r")) != NULL) { SID_fread_verify(&i_file, sizeof(int), 1, fp_test); SID_fread_verify(&n_files_SO, sizeof(int), 1, fp_test); SID_fread_verify(&n_SO, sizeof(int), 1, fp_test); SID_fread_verify(&n_SO_all, sizeof(int), 1, fp_test); fclose(fp_test); flag_multifile_SO = GBP_FALSE; if(n_SO != n_SO_all) SID_exit_error("Halo counts don't agree (ie. %d!=%d) in SO file.", SID_ERROR_LOGIC, n_SO, n_SO_all); if(n_files_SO != 1) SID_exit_error("Invalid file count (%d) in non-multifile SO file.", SID_ERROR_LOGIC, n_files_SO); } // Not all snapshots are garanteed to have an SO dataset. Continue if one isn't found else { flag_SO_present = GBP_FALSE; SID_log("Could not open SO dataset.", SID_LOG_COMMENT); } } if(i_file != 0) SID_exit_error("Invalid starting file index (%d) in SO file.", SID_ERROR_LOGIC, i_file); // Check that the halo counts in the properties and profiles datasets agree if(n_SO_all != n_props_all && flag_SO_present) SID_exit_error("The properties and SO halo counts don't agree (ie. %d!=%d)", SID_ERROR_LOGIC, n_SO_all, n_props_all); } // If there are fewer than 1000 halos, don't bother // writting to a multi-file int n_files_out = n_files_out_in; if(n_halos_all < GBP_MAX(n_files_out_in, 1000)) n_files_out = 1; // Perform rewrites int n_rewrite = 2; if(i_run == 1 && flag_SO_present) n_rewrite = 3; for(int i_rewrite = 0; i_rewrite < n_rewrite; i_rewrite++) { char *buffer = NULL; FILE *fp_read = NULL; FILE *fp_write = NULL; int i_file_read = 0; int i_file_write = 0; int i_halo_read = 0; // file index int i_halo_write = 0; // file index int j_halo_read = 0; // catalog_index int j_halo_write = 0; // catalog index int n_halos_read = 0; int n_halos_write = 0; int n_files_rewrite; int n_items_all; int flag_multifile; char *filename_items_in; char *filename_items_in_base; char *filename_items_out; char *filename_items_out_base; if(i_rewrite == 0) { SID_log("Processing properties...", SID_LOG_OPEN | SID_LOG_TIMER); buffer = (char *)SID_malloc(sizeof(halo_properties_info)); n_files_rewrite = n_files_props; n_items_all = n_props_all; flag_multifile = flag_multifile_properties; filename_items_in = filename_properties_in; filename_items_in_base = filename_properties_in_base; filename_items_out = filename_properties_out; filename_items_out_base = filename_properties_out_base; } else if(i_rewrite == 1) { SID_log("Processing profiles...", SID_LOG_OPEN | SID_LOG_TIMER); buffer = (char *)SID_malloc(sizeof(halo_profile_bin_info)); n_files_rewrite = n_files_profs; n_items_all = n_profs_all; flag_multifile = flag_multifile_profiles; filename_items_in = filename_profiles_in; filename_items_in_base = filename_profiles_in_base; filename_items_out = filename_profiles_out; filename_items_out_base = filename_profiles_out_base; } else if(i_rewrite == 2) { SID_log("Processing SO files...", SID_LOG_OPEN | SID_LOG_TIMER); buffer = (char *)SID_malloc(6 * sizeof(float)); n_files_rewrite = n_files_SO; n_items_all = n_SO_all; flag_multifile = flag_multifile_SO; filename_items_in = filename_SO_in; filename_items_in_base = filename_SO_in_base; filename_items_out = filename_SO_out; filename_items_out_base = filename_SO_out_base; } for(int i_halo = 0; i_halo < n_halos_all; i_halo++) { // Open a new input file if need-be while(i_halo_read >= n_halos_read && i_file_read < n_files_rewrite) { if(!flag_multifile && i_file_read > 0) SID_exit_error("Trying to open a second file in a non-multifile dataset.", SID_ERROR_LOGIC); if(flag_multifile) sprintf(filename_in, "%s/%s.%d", filename_items_in, filename_items_in_base, i_file_read); else sprintf(filename_in, "%s", filename_items_in); if(fp_read != NULL) fclose(fp_read); if((fp_read = fopen(filename_in, "r")) != NULL) { int n_files_in; SID_fread_verify(&i_file, sizeof(int), 1, fp_read); SID_fread_verify(&n_files_in, sizeof(int), 1, fp_read); SID_fread_verify(&n_halos_read, sizeof(int), 1, fp_read); SID_fread_verify(&n_items_all, sizeof(int), 1, fp_read); if(n_files_in != n_files_rewrite) SID_exit_error("File counts are not consistant (ie. %d!=%d).", SID_ERROR_LOGIC, n_files_in, n_files_rewrite); } else SID_exit_error("Could not open {%s}.", SID_ERROR_IO_OPEN, filename_in); if(i_file != i_file_read) SID_exit_error("Invalid file index in (ie. %d!=%d).", SID_ERROR_LOGIC, i_file, i_file_read); if(n_items_all != n_halos_all) SID_exit_error("Invalid total halo count in {%s} (ie. %d!=%d).", SID_ERROR_LOGIC, filename_in, n_items_all, n_halos_all); i_halo_read = 0; i_file_read++; } // Open a new output file if need-be if(i_halo_write >= n_halos_write) { if(n_files_out == 0 && i_file_write > 0) SID_exit_error("Trying to create a second file in a non-multifile dataset.", SID_ERROR_LOGIC); if(n_files_out > 1) { if(i_file_write == 0) mkdir(filename_items_out, 02755); sprintf(filename_out, "%s/%s.%d", filename_items_out, filename_items_out_base, i_file_write); } else sprintf(filename_out, "%s", filename_items_out); if(i_file_write == (n_files_out - 1)) n_halos_write = n_halos_all - i_halo_write; else n_halos_write = (int)((float)(i_file_write + 1) * (float)n_halos_all / (float)n_files_out) - j_halo_write; int n_halos_left = n_halos_all - j_halo_write; if(n_halos_write > n_halos_left) n_halos_write = n_halos_left; if(fp_write != NULL) fclose(fp_write); // SID_log("Opening {%s} for write.",SID_LOG_COMMENT,filename_out); if((fp_write = fopen(filename_out, "w")) != NULL) { fwrite(&i_file_write, sizeof(int), 1, fp_write); fwrite(&n_files_out, sizeof(int), 1, fp_write); fwrite(&n_halos_write, sizeof(int), 1, fp_write); fwrite(&n_halos_all, sizeof(int), 1, fp_write); } else SID_exit_error("Could not create properties file {%s}.", SID_ERROR_IO_OPEN, filename_out); i_halo_write = 0; i_file_write++; } switch(i_rewrite) { // Rewrite properties case 0: SID_fread_verify(buffer, sizeof(halo_properties_info), 1, fp_read); fwrite(buffer, sizeof(halo_properties_info), 1, fp_write); break; // Rewrite profiles case 1: { int n_bins; SID_fread_verify(&n_bins, sizeof(int), 1, fp_read); fwrite(&n_bins, sizeof(int), 1, fp_write); for(int i_bin = 0; i_bin < n_bins; i_bin++) { SID_fread_verify(buffer, sizeof(halo_profile_bin_info), 1, fp_read); fwrite(buffer, sizeof(halo_profile_bin_info), 1, fp_write); } break; } // Rewrite SOs case 2: SID_fread_verify(buffer, sizeof(float), 6, fp_read); fwrite(buffer, sizeof(float), 6, fp_write); break; } i_halo_read++; j_halo_read++; i_halo_write++; j_halo_write++; } // i_halo SID_free(SID_FARG buffer); if(fp_read != NULL) fclose(fp_read); if(fp_write != NULL) fclose(fp_write); fp_read = NULL; fp_write = NULL; // Sanity check if(j_halo_read != n_halos_all) SID_exit_error("The proper number of halos was not read (ie. %d!=%d).", SID_ERROR_IO_OPEN, j_halo_read, n_halos_all); if(j_halo_write != n_halos_all) SID_exit_error("The proper number of halos was not written (ie. %d!=%d).", SID_ERROR_IO_OPEN, j_halo_write, n_halos_all); // If any files need to be zero-filled, do so now for(; i_file_write < n_files_out; i_file_write++) { if(n_files_out == 0 && i_file_write > 0) SID_exit_error("Trying to create a second file in a non-multifile dataset.", SID_ERROR_LOGIC); if(n_files_out > 1) { if(i_file_write == 0) mkdir(filename_items_out, 02755); sprintf(filename_out, "%s/%s.%d", filename_items_out, filename_items_out_base, i_file_write); } else sprintf(filename_out, "%s", filename_items_out); if(i_file_write == (n_files_out - 1)) n_halos_write = n_halos_all - i_halo_write; else n_halos_write = (int)((float)(i_file_write + 1) * (float)n_halos_all / (float)n_files_out) - j_halo_write; int n_halos_left = n_halos_all - j_halo_write; if(n_halos_write > n_halos_left) n_halos_write = n_halos_left; if(fp_write != NULL) fclose(fp_write); // SID_log("Opening {%s} for write.",SID_LOG_COMMENT,filename_out); if((fp_write = fopen(filename_out, "w")) != NULL) { fwrite(&i_file_write, sizeof(int), 1, fp_write); fwrite(&n_files_out, sizeof(int), 1, fp_write); fwrite(&n_halos_write, sizeof(int), 1, fp_write); fwrite(&n_halos_all, sizeof(int), 1, fp_write); } else SID_exit_error("Could not create file {%s}.", SID_ERROR_IO_OPEN, filename_out); } if(fp_write != NULL) fclose(fp_write); SID_log("Done.", SID_LOG_CLOSE); } SID_log("Done.", SID_LOG_CLOSE); } // i_run SID_log("Done.", SID_LOG_CLOSE); } // i_snap SID_log("Done.", SID_LOG_CLOSE); SID_Finalize(); }
void init_cfunc(cfunc_info *cfunc,const char *filename_cosmology,int n_data, int n_random,int n_bits_PHK, double redshift, double box_size,int n_jack, double r_min_l1D, double r_max_1D,double dr_1D, double r_min_2D, double r_max_2D,double dr_2D){ SID_log("Initializing correlation function...",SID_LOG_OPEN); // Initialize flags cfunc->initialized =TRUE; cfunc->flag_compute_RR=TRUE; // Initialize constants cfunc->n_data =n_data; cfunc->n_random =n_random; cfunc->F_random =(double)n_random/(double)n_data; cfunc->redshift =redshift; cfunc->box_size =box_size; cfunc->n_jack =n_jack; cfunc->r_min_l1D =r_min_l1D; cfunc->lr_min_l1D=take_log10(r_min_l1D); cfunc->r_max_1D =r_max_1D; cfunc->r_min_2D =r_min_2D; cfunc->r_max_2D =r_max_2D; cfunc->r_max =MAX(cfunc->r_max_1D,cfunc->r_max_2D); cfunc->dr_1D =dr_1D; cfunc->dr_2D =dr_2D; // Decide on PHK boundary widths cfunc->n_bits_PHK=n_bits_PHK; for(cfunc->PHK_width=1;cfunc->PHK_width<20 && (double)cfunc->PHK_width*(cfunc->box_size/pow(2.,(double)(cfunc->n_bits_PHK)))<cfunc->r_max;) cfunc->PHK_width++; // Initialize the number of bins cfunc->n_1D =(int)(0.5+(cfunc->r_max_1D)/cfunc->dr_1D); cfunc->n_2D =(int)(0.5+(cfunc->r_max_2D-cfunc->r_min_2D)/cfunc->dr_2D); cfunc->n_2D_total =cfunc->n_2D*cfunc->n_2D; cfunc->n_jack_total=cfunc->n_jack*cfunc->n_jack*cfunc->n_jack; SID_log("keys =%d-bit", SID_LOG_COMMENT,cfunc->n_bits_PHK); SID_log("boundries =%d keys",SID_LOG_COMMENT,cfunc->PHK_width); SID_log("# of 1D bins=%d", SID_LOG_COMMENT,cfunc->n_1D); SID_log("# of 2D bins=%d", SID_LOG_COMMENT,cfunc->n_2D); // Initialize logarythmic bin sizes cfunc->dr_l1D=(take_log10(cfunc->r_max_1D)-cfunc->lr_min_l1D)/(double)cfunc->n_1D; // Initialize arrays cfunc->CFUNC_l1D =(double **)SID_malloc(sizeof(double *)*4); cfunc->dCFUNC_l1D=(double **)SID_malloc(sizeof(double *)*4); cfunc->COVMTX_l1D=(double **)SID_malloc(sizeof(double *)*4); cfunc->CFUNC_1D =(double **)SID_malloc(sizeof(double *)*4); cfunc->dCFUNC_1D =(double **)SID_malloc(sizeof(double *)*4); cfunc->COVMTX_1D =(double **)SID_malloc(sizeof(double *)*4); cfunc->CFUNC_2D =(double **)SID_malloc(sizeof(double *)*4); cfunc->dCFUNC_2D =(double **)SID_malloc(sizeof(double *)*4); cfunc->COVMTX_2D =(double **)SID_malloc(sizeof(double *)*4); int i_run; for(i_run=0;i_run<4;i_run++){ cfunc->CFUNC_l1D[i_run] =(double *)SID_malloc(sizeof(double)*(cfunc->n_1D)); cfunc->dCFUNC_l1D[i_run]=(double *)SID_malloc(sizeof(double)*(cfunc->n_1D)); cfunc->COVMTX_l1D[i_run]=(double *)SID_malloc(sizeof(double)*(cfunc->n_1D*cfunc->n_1D)); cfunc->CFUNC_1D[i_run] =(double *)SID_malloc(sizeof(double)*(cfunc->n_1D)); cfunc->dCFUNC_1D[i_run] =(double *)SID_malloc(sizeof(double)*(cfunc->n_1D)); cfunc->COVMTX_1D[i_run] =(double *)SID_malloc(sizeof(double)*(cfunc->n_1D*cfunc->n_1D)); cfunc->CFUNC_2D[i_run] =(double *)SID_malloc(sizeof(double)*(cfunc->n_2D)*(cfunc->n_2D)); cfunc->dCFUNC_2D[i_run] =(double *)SID_malloc(sizeof(double)*(cfunc->n_2D)*(cfunc->n_2D)); cfunc->COVMTX_2D[i_run] =(double *)SID_malloc(sizeof(double)*(cfunc->n_2D_total*cfunc->n_2D_total)); } cfunc->DD_l1D =(long long **)SID_malloc(sizeof(long long *)*(cfunc->n_jack_total+1)); cfunc->DR_l1D =(long long **)SID_malloc(sizeof(long long *)*(cfunc->n_jack_total+1)); cfunc->RR_l1D =(long long **)SID_malloc(sizeof(long long *)*(cfunc->n_jack_total+1)); cfunc->DD_1D =(long long **)SID_malloc(sizeof(long long *)*(cfunc->n_jack_total+1)); cfunc->DR_1D =(long long **)SID_malloc(sizeof(long long *)*(cfunc->n_jack_total+1)); cfunc->RR_1D =(long long **)SID_malloc(sizeof(long long *)*(cfunc->n_jack_total+1)); cfunc->DD_2D =(long long **)SID_malloc(sizeof(long long *)*(cfunc->n_jack_total+1)); cfunc->DR_2D =(long long **)SID_malloc(sizeof(long long *)*(cfunc->n_jack_total+1)); cfunc->RR_2D =(long long **)SID_malloc(sizeof(long long *)*(cfunc->n_jack_total+1)); int i_jack; for(i_jack=0;i_jack<=cfunc->n_jack_total;i_jack++){ cfunc->DD_l1D[i_jack]=(long long *)SID_calloc(sizeof(long long)*cfunc->n_1D); cfunc->DR_l1D[i_jack]=(long long *)SID_calloc(sizeof(long long)*cfunc->n_1D); cfunc->RR_l1D[i_jack]=(long long *)SID_calloc(sizeof(long long)*cfunc->n_1D); cfunc->DD_1D[i_jack] =(long long *)SID_calloc(sizeof(long long)*cfunc->n_1D); cfunc->DR_1D[i_jack] =(long long *)SID_calloc(sizeof(long long)*cfunc->n_1D); cfunc->RR_1D[i_jack] =(long long *)SID_calloc(sizeof(long long)*cfunc->n_1D); cfunc->DD_2D[i_jack] =(long long *)SID_calloc(sizeof(long long)*cfunc->n_2D*cfunc->n_2D); cfunc->DR_2D[i_jack] =(long long *)SID_calloc(sizeof(long long)*cfunc->n_2D*cfunc->n_2D); cfunc->RR_2D[i_jack] =(long long *)SID_calloc(sizeof(long long)*cfunc->n_2D*cfunc->n_2D); } // Initialize the cosmology if(filename_cosmology==NULL) init_cosmo_default(&(cfunc->cosmo)); else read_gbpCosmo_file(&(cfunc->cosmo),filename_cosmology); SID_log("Done.",SID_LOG_CLOSE); }
void read_MCMC_state(MCMC_info *MCMC){ char filename_output_dir[MAX_FILENAME_LENGTH]; char filename_chain_dir[MAX_FILENAME_LENGTH]; char filename_results_dir[MAX_FILENAME_LENGTH]; char filename_plots_dir[MAX_FILENAME_LENGTH]; char filename_run[MAX_FILENAME_LENGTH]; char filename_chain[MAX_FILENAME_LENGTH]; char filename_chain_config[MAX_FILENAME_LENGTH]; char filename_stats[MAX_FILENAME_LENGTH]; char filename_coverage[MAX_FILENAME_LENGTH]; char filename_chain_covariance[MAX_FILENAME_LENGTH]; char filename_covariance[MAX_FILENAME_LENGTH]; char filename_histograms[MAX_FILENAME_LENGTH]; char filename_results[MAX_FILENAME_LENGTH]; char filename_stop[MAX_FILENAME_LENGTH]; char format_string[32]; int my_chain; int i_P,i_DS,i_M,i_array; double *V_read; FILE *fp_run; FILE *fp_chain; FILE *fp_chain_config; FILE *fp_stats; FILE *fp_coverage; FILE *fp_chain_covariance; FILE *fp_covariance; FILE *fp_histograms; FILE *fp_results; FILE *fp_stop; MCMC_DS_info *current_DS; set_MCMC_mode(MCMC,MCMC_MODE_DEFAULT); my_chain=MCMC->my_chain; SID_log("Reading MCMC state from {%s}...",SID_LOG_OPEN,MCMC->filename_output_dir); // Set directories sprintf(filename_output_dir, "%s/", MCMC->filename_output_dir); sprintf(filename_chain_dir, "%s/chains/", MCMC->filename_output_dir); sprintf(filename_results_dir,"%s/results/",MCMC->filename_output_dir); sprintf(filename_plots_dir, "%s/plots/", MCMC->filename_output_dir); // Set filenames sprintf(filename_run, "%s/run.dat", MCMC->filename_output_dir); sprintf(filename_chain, "%s/chain_trace_%06d.dat", filename_chain_dir,my_chain); sprintf(filename_chain_config, "%s/chain_config_%06d.dat", filename_chain_dir,my_chain); sprintf(filename_chain_covariance,"%s/chain_covariance_%06d.dat",filename_chain_dir,my_chain); sprintf(filename_stats, "%s/chain_stats_%06d.dat", filename_chain_dir,my_chain); sprintf(filename_coverage, "%s/coverage.dat", filename_results_dir); sprintf(filename_histograms, "%s/histograms.dat", filename_results_dir); sprintf(filename_covariance, "%s/covariance.dat", filename_results_dir); MCMC->map_P_to_M =NULL; MCMC->compute_MCMC_ln_likelihood=compute_MCMC_ln_likelihood_default; MCMC->params =NULL; MCMC->temperature =1.0; MCMC->n_P =0; MCMC->n_thin =1; MCMC->n_DS =0; MCMC->n_M_total =0; MCMC->n_arrays =0; MCMC->n_M =NULL; MCMC->array =NULL; MCMC->V =NULL; MCMC->m =NULL; MCMC->b =NULL; MCMC->RNG =NULL; MCMC->flag_integrate_on =TRUE; MCMC->flag_analysis_on =TRUE; MCMC->first_map_call =TRUE; MCMC->mode =MCMC_MODE_DEFAULT; MCMC->DS =NULL; MCMC->last =NULL; // Read/Write Header file if((fp_run=fopen(filename_run,"rb"))!=NULL){ fp_run=fopen(filename_run,"rb"); fread(MCMC->problem_name, sizeof(char),MCMC_NAME_SIZE,fp_run); fread(&(MCMC->n_chains), sizeof(int), 1,fp_run); fread(&(MCMC->n_avg), sizeof(int), 1,fp_run); fread(&(MCMC->flag_autocor_on), sizeof(int), 1,fp_run); fread(&(MCMC->flag_no_map_write),sizeof(int), 1,fp_run); fread(&(MCMC->n_P), sizeof(int), 1,fp_run); SID_log("Problem name ={%s}",SID_LOG_COMMENT,MCMC->problem_name); SID_log("n_avg ={%d}",SID_LOG_COMMENT,MCMC->n_avg); SID_log("flag_autocor_on ={%d}",SID_LOG_COMMENT,MCMC->flag_autocor_on); MCMC->P_names =(char **)SID_malloc(sizeof(char *)*MCMC->n_P); MCMC->P_init =(double *)SID_malloc(sizeof(double)*MCMC->n_P); MCMC->P_new =(double *)SID_malloc(sizeof(double)*MCMC->n_P); MCMC->P_last =(double *)SID_malloc(sizeof(double)*MCMC->n_P); MCMC->P_chain =(double *)SID_malloc(sizeof(double)*MCMC->n_P); MCMC->P_limit_min =(double *)SID_malloc(sizeof(double)*MCMC->n_P); MCMC->P_limit_max =(double *)SID_malloc(sizeof(double)*MCMC->n_P); for(i_P=0;i_P<MCMC->n_P;i_P++) MCMC->P_limit_min[i_P]=-DBL_MAX*1e-3; for(i_P=0;i_P<MCMC->n_P;i_P++) MCMC->P_limit_max[i_P]=DBL_MAX*1e-3; SID_log("Parameters (name, initial_value,limit min,limit max):",SID_LOG_OPEN); MCMC->P_name_length=0; for(i_P=0;i_P<MCMC->n_P;i_P++){ MCMC->P_names[i_P]=(char *)SID_malloc(sizeof(char)*MCMC_NAME_SIZE); fread(MCMC->P_names[i_P], sizeof(char), MCMC_NAME_SIZE,fp_run); fread(&(MCMC->P_init[i_P]), sizeof(double), 1,fp_run); fread(&(MCMC->P_limit_min[i_P]),sizeof(double), 1,fp_run); fread(&(MCMC->P_limit_max[i_P]),sizeof(double), 1,fp_run); MCMC->P_name_length=MAX(MCMC->P_name_length,strlen(MCMC->P_names[i_P])); } sprintf(MCMC->P_name_format,"%%-%ds", MCMC->P_name_length); sprintf(format_string, "%s %%13.6le %%13.6le %%13.6le",MCMC->P_name_format); for(i_P=0;i_P<MCMC->n_P;i_P++) SID_log(format_string,SID_LOG_COMMENT,MCMC->P_names[i_P],MCMC->P_init[i_P],MCMC->P_limit_min[i_P],MCMC->P_limit_max[i_P]); SID_log(NULL,SID_LOG_CLOSE|SID_LOG_NOPRINT); fread(&(MCMC->n_arrays),sizeof(int),1,fp_run); SID_log("n_arrays=%d", SID_LOG_OPEN,MCMC->n_arrays); MCMC->array =(double **)SID_malloc(sizeof(double *)*MCMC->n_arrays); MCMC->array_name=(char **)SID_malloc(sizeof(char *)*MCMC->n_arrays); for(i_array=0;i_array<MCMC->n_arrays;i_array++){ MCMC->array[i_array] =(double *)SID_malloc(sizeof(double)*MCMC->n_P); MCMC->array_name[i_array]=(char *)SID_malloc(sizeof(char)*MCMC_NAME_SIZE); fread(MCMC->array_name[i_array],sizeof(char), MCMC_NAME_SIZE,fp_run); fread(MCMC->array[i_array], sizeof(double),MCMC->n_P, fp_run); SID_log("array #%03d name ={%s}",SID_LOG_COMMENT,i_array,MCMC->array_name[i_array]); } SID_log(NULL,SID_LOG_CLOSE|SID_LOG_NOPRINT); fread(&(MCMC->n_DS),sizeof(int),1,fp_run); SID_log("Reading %d datasets...",SID_LOG_OPEN,MCMC->n_DS); for(i_DS=0;i_DS<MCMC->n_DS;i_DS++){ SID_log("Dataset #%03d:",SID_LOG_OPEN,i_DS); current_DS =(MCMC_DS_info *)SID_malloc(sizeof(MCMC_DS_info)); fread(current_DS->name, sizeof(char),MCMC_NAME_SIZE,fp_run); fread(&(current_DS->n_M),sizeof(int), 1,fp_run); MCMC->n_M_total+=current_DS->n_M; SID_log("name ={%s}",SID_LOG_COMMENT,current_DS->name); SID_log("n_M =%d", SID_LOG_COMMENT,current_DS->n_M); current_DS->M_target =(double *)SID_malloc(sizeof(double)*current_DS->n_M); current_DS->dM_target=(double *)SID_malloc(sizeof(double)*current_DS->n_M); current_DS->params =NULL; fread(current_DS->M_target, sizeof(double),current_DS->n_M,fp_run); fread(current_DS->dM_target, sizeof(double),current_DS->n_M,fp_run); fread(&(current_DS->n_arrays),sizeof(int), 1,fp_run); SID_log("n_arrays=%d", SID_LOG_OPEN,current_DS->n_arrays); current_DS->array =(double **)SID_malloc(sizeof(double *)*current_DS->n_arrays); current_DS->array_name=(char **)SID_malloc(sizeof(char *)*current_DS->n_arrays); for(i_array=0;i_array<current_DS->n_arrays;i_array++){ current_DS->array[i_array] =(double *)SID_malloc(sizeof(double)*current_DS->n_M); current_DS->array_name[i_array]=(char *)SID_malloc(sizeof(char)*MCMC_NAME_SIZE); fread(current_DS->array_name[i_array],sizeof(char), MCMC_NAME_SIZE, fp_run); fread(current_DS->array[i_array], sizeof(double),current_DS->n_M,fp_run); SID_log("array #%03d name={%s}",SID_LOG_COMMENT,i_array,current_DS->array_name[i_array]); } SID_log(NULL,SID_LOG_CLOSE|SID_LOG_NOPRINT); current_DS->next=NULL; if(MCMC->DS==NULL) MCMC->DS=current_DS; else MCMC->last->next=current_DS; MCMC->last=current_DS; SID_log(NULL,SID_LOG_CLOSE|SID_LOG_NOPRINT); } SID_log("Done.",SID_LOG_CLOSE); fclose(fp_run); } // ... fetch the number of intervals that have already been computed ... fp_chain_config=fopen(filename_chain_config,"rb"); V_read=(double *)SID_malloc(sizeof(double)*MCMC->n_P*MCMC->n_P); fread(&(MCMC->n_iterations), sizeof(int), 1, fp_chain_config); fread(&(MCMC->n_iterations_burn),sizeof(int), 1, fp_chain_config); // ... fetch the temperature and covariance matrix that was being used fread(&(MCMC->temperature), sizeof(double),1, fp_chain_config); fread(V_read, sizeof(double),MCMC->n_P*MCMC->n_P,fp_chain_config); set_MCMC_covariance(MCMC,V_read); SID_free(SID_FARG V_read); // Initialize dataset arrays init_MCMC_arrays(MCMC); SID_log("# burn iterations = %d", SID_LOG_COMMENT,MCMC->n_iterations_burn); SID_log("# total iterations = %d", SID_LOG_COMMENT,MCMC->n_iterations); SID_log("Temperature = %le",SID_LOG_COMMENT,MCMC->temperature); fclose(fp_chain_config); SID_log("Done.",SID_LOG_CLOSE); }
void init_field(int n_d, int *n, double *L, field_info *FFT) { ptrdiff_t n_x_local; ptrdiff_t i_x_start_local; ptrdiff_t n_y_transpose_local; ptrdiff_t i_y_start_transpose_local; ptrdiff_t *n_x_rank; int flag_active; int n_active; int min_size, max_size; SID_log("Initializing ", SID_LOG_OPEN); for(ptrdiff_t i_d = 0; i_d < n_d; i_d++) { if(i_d < (n_d - 1)) SID_log("%dx", SID_LOG_CONTINUE, n[i_d]); else SID_log("%d element %d-d FFT ", SID_LOG_CONTINUE, n[i_d], n_d); } SID_log("(%d byte precision)...", SID_LOG_CONTINUE, (int)sizeof(GBPREAL)); // Initialize FFT sizes FFT->n_d = n_d; FFT->n = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d); FFT->L = (double *)SID_calloc(sizeof(double) * FFT->n_d); FFT->n_k_local = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d); FFT->n_R_local = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d); FFT->i_R_start_local = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d); FFT->i_k_start_local = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d); FFT->i_R_stop_local = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d); FFT->i_k_stop_local = (ptrdiff_t *)SID_calloc(sizeof(ptrdiff_t) * FFT->n_d); for(ptrdiff_t i_d = 0; i_d < FFT->n_d; i_d++) { FFT->n[i_d] = n[i_d]; FFT->L[i_d] = L[i_d]; FFT->i_R_start_local[i_d] = 0; FFT->i_k_start_local[i_d] = 0; FFT->n_R_local[i_d] = FFT->n[i_d]; FFT->n_k_local[i_d] = FFT->n[i_d]; } FFT->n_k_local[FFT->n_d - 1] = FFT->n[FFT->n_d - 1] / 2 + 1; // Initialize FFTW // Create an integer version of FFT->n[] to pass to ..._create_plan int *n_int=(int *)SID_malloc(sizeof(int)*FFT->n_d); for(int i_d=0;i_d<FFT->n_d;i_d++) n_int[i_d]=(int)FFT->n[i_d]; #if FFTW_V2 #if USE_MPI int total_local_size_int; int n_x_local_int; int i_x_start_local_int; int n_y_transpose_local_int; int i_y_start_transpose_local_int; FFT->plan = rfftwnd_mpi_create_plan(SID.COMM_WORLD->comm, FFT->n_d, n_int, FFTW_REAL_TO_COMPLEX, FFTW_ESTIMATE); FFT->iplan = rfftwnd_mpi_create_plan(SID.COMM_WORLD->comm, FFT->n_d, n_int, FFTW_COMPLEX_TO_REAL, FFTW_ESTIMATE); rfftwnd_mpi_local_sizes(FFT->plan, &(n_x_local_int), &(i_x_start_local_int), &(n_y_transpose_local_int), &(i_y_start_transpose_local_int), &total_local_size_int); n_x_local = (ptrdiff_t)n_x_local_int; i_x_start_local = (ptrdiff_t)i_x_start_local_int; n_y_transpose_local = (ptrdiff_t)n_y_transpose_local_int; i_y_start_transpose_local = (ptrdiff_t)i_y_start_transpose_local_int; FFT->total_local_size = (size_t)total_local_size_int; #else FFT->total_local_size = 1; for(ptrdiff_t i_d = 0; i_d < FFT->n_d; i_d++) { if(i_d < FFT->n_d - 1) FFT->total_local_size *= FFT->n[i_d]; else FFT->total_local_size *= 2 * (FFT->n[i_d] / 2 + 1); } #if USE_DOUBLE FFT->plan = fftwnd_create_plan(FFT->n_d, n_int, FFTW_REAL_TO_COMPLEX, FFTW_ESTIMATE | FFTW_IN_PLACE); FFT->iplan = fftwnd_create_plan(FFT->n_d, n_int, FFTW_COMPLEX_TO_REAL, FFTW_ESTIMATE | FFTW_IN_PLACE); #else FFT->plan = rfftwnd_create_plan(FFT->n_d, n_int, FFTW_REAL_TO_COMPLEX, FFTW_ESTIMATE | FFTW_IN_PLACE); FFT->iplan = rfftwnd_create_plan(FFT->n_d, n_int, FFTW_COMPLEX_TO_REAL, FFTW_ESTIMATE | FFTW_IN_PLACE); #endif #endif #else #if USE_MPI #if USE_DOUBLE fftw_mpi_init(); FFT->total_local_size = fftw_mpi_local_size_many_transposed(FFT->n_d, FFT->n, 1, FFTW_MPI_DEFAULT_BLOCK, FFTW_MPI_DEFAULT_BLOCK, SID_COMM_WORLD->comm, &(n_x_local), &(i_x_start_local), &(n_y_transpose_local), &(i_y_start_transpose_local)); FFT->plan = fftw_mpi_plan_dft_r2c(FFT->n_d, FFT->n, FFT->field_local, FFT->cfield_local, SID_COMM_WORLD->comm, FFTW_ESTIMATE); FFT->iplan = fftw_mpi_plan_dft_c2r(FFT->n_d, FFT->n, FFT->cfield_local, FFT->field_local, SID_COMM_WORLD->comm, FFTW_ESTIMATE); #else fftwf_mpi_init(); FFT->total_local_size = fftwf_mpi_local_size_many_transposed(FFT->n_d, FFT->n, 1, FFTW_MPI_DEFAULT_BLOCK, FFTW_MPI_DEFAULT_BLOCK, SID_COMM_WORLD->comm, &(n_x_local), &(i_x_start_local), &(n_y_transpose_local), &(i_y_start_transpose_local)); FFT->plan = fftwf_mpi_plan_dft_r2c(FFT->n_d, FFT->n, FFT->field_local, FFT->cfield_local, SID_COMM_WORLD->comm, FFTW_ESTIMATE); FFT->iplan = fftwf_mpi_plan_dft_c2r(FFT->n_d, FFT->n, FFT->cfield_local, FFT->field_local, SID_COMM_WORLD->comm, FFTW_ESTIMATE); #endif #else FFT->total_local_size = 1; for(ptrdiff_t i_d=0; i_d < FFT->n_d; i_d++) { if(i_d < FFT->n_d - 1) FFT->total_local_size *= FFT->n[i_d]; else FFT->total_local_size *= 2 * (FFT->n[i_d] / 2 + 1); } #if USE_DOUBLE FFT->plan = fftw_plan_dft_r2c(FFT->n_d, FFT->n, FFT->field_local, FFT->cfield_local, FFTW_ESTIMATE); FFT->iplan = fftw_plan_dft_c2r(FFT->n_d, FFT->n, FFT->cfield_local, FFT->field_local, FFTW_ESTIMATE); #else FFT->plan = fftwf_plan_dft_r2c(FFT->n_d, FFT->n, FFT->field_local, FFT->cfield_local, FFTW_ESTIMATE); FFT->iplan = fftwf_plan_dft_c2r(FFT->n_d, FFT->n, FFT->cfield_local, FFT->field_local, FFTW_ESTIMATE); #endif #endif #endif SID_free(SID_FARG n_int); // Set empty slabs to start at 0 to make ignoring them simple. if(n_x_local == 0) i_x_start_local = 0; if(n_y_transpose_local == 0) i_y_start_transpose_local = 0; // Modify the local slab dimensions according to what FFTW chose. FFT->i_R_start_local[0] = i_x_start_local; FFT->n_R_local[0] = n_x_local; if(FFT->n_d > 1) { FFT->i_k_start_local[1] = i_y_start_transpose_local; FFT->n_k_local[1] = n_y_transpose_local; } // Allocate field #if USE_FFTW3 FFT->field_local = (gbpFFT_real *)fftwf_alloc_real(FFT->total_local_size); #else FFT->field_local = (gbpFFT_real *)SID_malloc(sizeof(gbpFFT_real)*FFT->total_local_size); #endif FFT->cfield_local = (gbpFFT_complex *)FFT->field_local; // Upper limits of slab decomposition for(ptrdiff_t i_d = 0; i_d < FFT->n_d; i_d++) { FFT->i_R_stop_local[i_d] = FFT->i_R_start_local[i_d] + FFT->n_R_local[i_d] - 1; FFT->i_k_stop_local[i_d] = FFT->i_k_start_local[i_d] + FFT->n_k_local[i_d] - 1; } // FFTW padding sizes if(FFT->n_d > 1) { FFT->pad_size_R = 2 * (FFT->n_R_local[FFT->n_d - 1] / 2 + 1) - FFT->n_R_local[FFT->n_d - 1]; FFT->pad_size_k = 0; } else { FFT->pad_size_R = 0; FFT->pad_size_k = 0; } // Number of elements (global and local) in the FFT ptrdiff_t i_d = 0; for(FFT->n_field = 1, FFT->n_field_R_local = 1, FFT->n_field_k_local = 1; i_d < FFT->n_d; i_d++) { FFT->n_field *= (size_t)FFT->n[i_d]; FFT->n_field_R_local *= (size_t)FFT->n_R_local[i_d]; FFT->n_field_k_local *= (size_t)FFT->n_k_local[i_d]; } // Clear the field clear_field(FFT); // Initialize the FFT's real-space grid FFT->R_field = (double **)SID_malloc(sizeof(double *) * FFT->n_d); FFT->dR = (double *)SID_malloc(sizeof(double *) * FFT->n_d); for(ptrdiff_t i_d = 0; i_d < FFT->n_d; i_d++) { FFT->R_field[i_d] = (double *)SID_malloc(sizeof(double) * (FFT->n[i_d] + 1)); FFT->dR[i_d] = FFT->L[i_d] / (double)(FFT->n[i_d]); for(ptrdiff_t i_i = 0; i_i < FFT->n[i_d]; i_i++) FFT->R_field[i_d][i_i] = FFT->L[i_d] * ((double)i_i / (double)(FFT->n[i_d])); FFT->R_field[i_d][FFT->n[i_d]] = FFT->L[i_d]; } // Initialize the FFT's k-space grid FFT->k_field = (double **)SID_malloc(sizeof(double *) * FFT->n_d); FFT->dk = (double *)SID_malloc(sizeof(double *) * FFT->n_d); FFT->k_Nyquist = (double *)SID_malloc(sizeof(double *) * FFT->n_d); for(ptrdiff_t i_d = 0; i_d < FFT->n_d; i_d++) { FFT->k_field[i_d] = (double *)SID_malloc(sizeof(double) * FFT->n[i_d]); FFT->dk[i_d] = TWO_PI / FFT->L[i_d]; FFT->k_Nyquist[i_d] = TWO_PI * (double)(FFT->n[i_d]) / FFT->L[i_d] / 2.; for(ptrdiff_t i_i = 0; i_i < FFT->n[i_d]; i_i++) { if(i_i >= FFT->n[i_d] / 2) FFT->k_field[i_d][i_i] = TWO_PI * (double)(i_i - FFT->n[i_d]) / FFT->L[i_d]; else FFT->k_field[i_d][i_i] = TWO_PI * (double)(i_i) / FFT->L[i_d]; } } // Flags FFT->flag_padded = GBP_FALSE; // Slab info FFT->slab.n_x_local = FFT->n_R_local[0]; FFT->slab.i_x_start_local = FFT->i_R_start_local[0]; FFT->slab.i_x_stop_local = FFT->i_R_stop_local[0]; FFT->slab.x_min_local = FFT->R_field[0][FFT->i_R_start_local[0]]; if(FFT->slab.n_x_local > 0) FFT->slab.x_max_local = FFT->R_field[0][FFT->i_R_stop_local[0] + 1]; else FFT->slab.x_max_local = FFT->slab.x_min_local; SID_Allreduce(&(FFT->slab.x_max_local), &(FFT->slab.x_max), 1, SID_DOUBLE, SID_MAX, SID_COMM_WORLD); #if USE_MPI // All ranks are not necessarily assigned any slices, so // we need to figure out what ranks are to the right and the left for // buffer exchanges n_x_rank = (ptrdiff_t *)SID_malloc(sizeof(ptrdiff_t) * SID.n_proc); n_x_rank[SID.My_rank] = (ptrdiff_t)FFT->slab.n_x_local; if(n_x_rank[SID.My_rank] > 0) flag_active = GBP_TRUE; else flag_active = GBP_FALSE; SID_Allreduce(&flag_active, &n_active, 1, SID_INT, SID_SUM, SID_COMM_WORLD); SID_Allreduce(&n_x_rank[SID.My_rank], &min_size, 1, SID_INT, SID_MIN, SID_COMM_WORLD); SID_Allreduce(&n_x_rank[SID.My_rank], &max_size, 1, SID_INT, SID_MAX, SID_COMM_WORLD); for(int i_rank = 0; i_rank < SID.n_proc; i_rank++) SID_Bcast(&(n_x_rank[i_rank]), 1, SID_INT, i_rank, SID_COMM_WORLD); FFT->slab.rank_to_right = -1; for(int i_rank = SID.My_rank + 1; i_rank < SID.My_rank + SID.n_proc && FFT->slab.rank_to_right < 0; i_rank++) { int j_rank = i_rank % SID.n_proc; if(n_x_rank[j_rank] > 0) FFT->slab.rank_to_right = j_rank; } if(FFT->slab.rank_to_right < 0) FFT->slab.rank_to_right = SID.My_rank; FFT->slab.rank_to_left = -1; for(int i_rank = SID.My_rank - 1; i_rank > SID.My_rank - SID.n_proc && FFT->slab.rank_to_left < 0; i_rank--) { int j_rank = i_rank; if(i_rank < 0) j_rank = i_rank + SID.n_proc; if(n_x_rank[j_rank] > 0) FFT->slab.rank_to_left = j_rank; } if(FFT->slab.rank_to_left < 0) FFT->slab.rank_to_left = SID.My_rank; free(n_x_rank); SID_log("(%d cores unused, min/max slab size=%d/%d)...", SID_LOG_CONTINUE, SID.n_proc - n_active, min_size, max_size); #else FFT->slab.rank_to_right = SID.My_rank; FFT->slab.rank_to_left = SID.My_rank; if(FFT->slab.n_x_local > 0) { flag_active = GBP_TRUE; n_active = 1; min_size = FFT->slab.n_x_local; max_size = FFT->slab.n_x_local; } else { flag_active = GBP_FALSE; n_active = 0; min_size = 0; max_size = 0; } #endif SID_log("Done.", SID_LOG_CLOSE); }
size_t mark_particles(plist_info *plist, int run_mode, double *input_vals, const char *mark_name) { size_t n_particles; size_t n_particles_local; size_t i_particle; int i_species; size_t * id; GBPREAL *x; GBPREAL *y; GBPREAL *z; GBPREAL r; int * mark_array; int flag_volume; int flag_volume_sphere; size_t n_marked_local = 0; size_t n_marked = 0; // Interpret run-mode flag_volume = SID_CHECK_BITFIELD_SWITCH(run_mode, VOLUME_BOX) || SID_CHECK_BITFIELD_SWITCH(run_mode, VOLUME_SPHERE); flag_volume_sphere = SID_CHECK_BITFIELD_SWITCH(run_mode, VOLUME_SPHERE); // Loop over all species for(i_species = 0; i_species < N_GADGET_TYPE; i_species++) { if(ADaPS_exist(plist->data, "n_all_%s", plist->species[i_species])) { n_particles = ((size_t *)ADaPS_fetch(plist->data, "n_all_%s", plist->species[i_species]))[0]; n_particles_local = ((size_t *)ADaPS_fetch(plist->data, "n_%s", plist->species[i_species]))[0]; // If this species has local particles if(n_particles_local > 0) { mark_array = (int *)SID_malloc(sizeof(int) * n_particles_local); // Mark particles in a volume if(flag_volume) { x = (GBPREAL *)ADaPS_fetch(plist->data, "x_%s", plist->species[i_species]); y = (GBPREAL *)ADaPS_fetch(plist->data, "y_%s", plist->species[i_species]); z = (GBPREAL *)ADaPS_fetch(plist->data, "z_%s", plist->species[i_species]); // Loop over all particles for(i_particle = 0; i_particle < n_particles_local; i_particle++) { mark_array[i_particle] = GBP_FALSE; switch(flag_volume_sphere) { case GBP_TRUE: if(add_quad(3, (double)(x[i_particle]) - input_vals[0], (double)(y[i_particle]) - input_vals[1], (double)(z[i_particle]) - input_vals[2]) <= input_vals[3]) mark_array[i_particle] = GBP_TRUE; break; case GBP_FALSE: if(x[i_particle] >= (GBPREAL)input_vals[0] && x[i_particle] <= (GBPREAL)input_vals[1]) { if(y[i_particle] >= (GBPREAL)input_vals[2] && y[i_particle] <= (GBPREAL)input_vals[3]) { if(z[i_particle] >= (GBPREAL)input_vals[4] && z[i_particle] <= (GBPREAL)input_vals[5]) { mark_array[i_particle] = GBP_TRUE; } } } break; } } } // Mark particles by property else { } for(i_particle = 0; i_particle < n_particles_local; i_particle++) if(mark_array[i_particle]) n_marked_local++; ADaPS_store(&(plist->data), (void *)mark_array, "%s_%s", ADaPS_DEFAULT, mark_name, plist->species[i_species]); } } } calc_sum_global(&n_marked_local, &n_marked, 1, SID_SIZE_T, CALC_MODE_DEFAULT, SID_COMM_WORLD); return (n_marked); }
void compute_trees_horizontal(char *filename_halo_root_in, char *filename_cat_root_in, char *filename_snap_list_in, char *filename_root_matches, char *filename_output_dir, cosmo_info **cosmo, int i_read_start, int i_read_stop, int i_read_step, int n_search, int flag_fix_bridges, int *flag_clean){ char group_text_prefix[5]; FILE *fp; char *line=NULL; int line_length=0; int n_strays; int n_strays_drop; int n_strays_bridge; int i_stray; int n_match; int n_match_halos; int n_back_match; int i_match; int j_match; int k_match; int n_groups_1; int n_groups_2; int n_groups_3; int i_group; int j_group; int k_group; int l_group; int n_subgroups_1; int n_subgroups_2; int i_subgroup; int j_subgroup; int i_drop; int j_drop; int k_drop; int i_bridge; int j_bridge; int n_lines; int i_file; int j_file; int i_write; int j_write; int l_write; int l_read; int j_file_1; int j_file_2; int i_read; int j_read; int j_read_1; int j_read_2; int n_descendant; int n_progenitor; int descendant_index; int progenitor_index; int my_descendant_index,my_descendant_id,my_descendant_list,my_index; int index; int max_id =0; int max_id_group =0; int max_id_subgroup=0; int *my_descendant; int *n_particles; int *n_particles_groups; int *n_particles_subgroups; int my_trunk; double expansion_factor; int n_found; int n_found_bridge; double delta_r; double delta_M; double R_vir_p; double R_vir_d; int i_find,n_find; int flag_continue; int flag_drop; int *match_id=NULL; int *search_id=NULL; int n_progenitors_max; int i_search; int flag_dropped; int flag_first; int n_particles_max; int trunk_index; int *n_groups=NULL; int *n_subgroups=NULL; int max_tree_id_group; int max_tree_id_subgroup; int max_tree_id; int **n_subgroups_group=NULL; int *n_subgroups_group_1=NULL; size_t **sort_id=NULL; size_t **sort_group_id=NULL; size_t **sort_subgroup_id=NULL; size_t *match_index=NULL; size_t *bridge_index=NULL; size_t *search_index=NULL; float *match_score=NULL; char *match_flag_two_way=NULL; int *bridge_keep=NULL; int flag_match_subgroups; int flag_keep_strays=FALSE; int n_k_match=2; int n_snap; tree_horizontal_info **subgroups; tree_horizontal_info **groups; tree_horizontal_info **halos; tree_horizontal_info *halos_i; match_info **back_matches_groups; match_info **back_matches_subgroups; match_info **back_matches; int n_files; int n_subgroups_max; int n_groups_max; int *n_halos; int n_halos_max; int n_halos_i; int i_halo; int n_halos_1_matches; int n_halos_2_matches; int j_halo; int k_halo; int l_halo; int n_list; int k_file; int l_file; int k_index; int k_file_temp; int k_index_temp; int n_wrap; int i_file_start; char filename_output_dir_horizontal[MAX_FILENAME_LENGTH]; char filename_output_dir_horizontal_cases[MAX_FILENAME_LENGTH]; char filename_output_file_root[MAX_FILENAME_LENGTH]; char filename_matching_out[MAX_FILENAME_LENGTH]; FILE *fp_matching_out; int i_column; SID_log("Constructing horizontal merger trees for snapshots #%d->#%d (step=%d)...",SID_LOG_OPEN|SID_LOG_TIMER,i_read_start,i_read_stop,i_read_step); if(n_search<1) SID_trap_error("n_search=%d but must be at least 1",ERROR_LOGIC,n_search); int flag_compute_fragmented=TRUE; int flag_compute_ghosts =FALSE; if(!flag_fix_bridges) SID_log("Bridge-fixing is turned off.",SID_LOG_COMMENT); if(!flag_compute_fragmented) SID_log("Fragmented-halo propagation is turned off.",SID_LOG_COMMENT); if(!flag_compute_ghosts) SID_log("Ghost-populated tree construction is turned off.",SID_LOG_COMMENT); // Create the output directory mkdir(filename_output_dir,02755); // Create snapshot expansion factor list double *a_list=NULL; int n_a_list_in; write_a_list(filename_snap_list_in, filename_output_dir, i_read_start, i_read_stop, i_read_step); read_a_list(filename_output_dir, &a_list, &n_a_list_in); write_tree_run_parameters(filename_output_dir, i_read_start, i_read_stop, i_read_step, n_search, flag_fix_bridges, flag_compute_fragmented, flag_compute_ghosts); // Validate existing matching files &/or perfrom matching //if(!compute_trees_matches(filename_halo_root_in, // filename_root_matches, // i_read_start, // i_read_stop, // i_read_step, // n_search, // WRITE_MATCHES_MODE_TREES|WRITE_MATCHES_PERFORM_CHECK)) // SID_trap_error("Matching could not be completed. Terminating.",ERROR_LOGIC); read_matches_header(filename_root_matches, i_read_start, i_read_stop, i_read_step, &n_files, &n_subgroups, &n_groups, &n_subgroups_max, &n_groups_max, &n_halos_max); // We need these for allocating arrays calc_max(n_subgroups,&n_subgroups_max,n_files,SID_INT,CALC_MODE_DEFAULT); calc_max(n_groups, &n_groups_max, n_files,SID_INT,CALC_MODE_DEFAULT); n_halos_max=MAX(n_subgroups_max,n_groups_max); // We need enough indices to allow us to hold-on to descendants until outputing // and for the current and last i_file as well n_wrap =2*n_search+2; i_file_start=n_files-1; // Initialize arrays SID_log("Creating arrays...",SID_LOG_OPEN); n_particles_groups =(int *)SID_malloc(sizeof(int) *n_halos_max); n_particles_subgroups =(int *)SID_malloc(sizeof(int) *n_halos_max); match_id =(int *)SID_malloc(sizeof(int) *n_halos_max); match_score =(float *)SID_malloc(sizeof(float) *n_halos_max); match_index =(size_t *)SID_malloc(sizeof(size_t)*n_halos_max); match_flag_two_way =(char *)SID_malloc(sizeof(char) *n_halos_max); subgroups =(tree_horizontal_info **)SID_malloc(sizeof(tree_horizontal_info *)*n_wrap); groups =(tree_horizontal_info **)SID_malloc(sizeof(tree_horizontal_info *)*n_wrap); n_subgroups_group =(int **)SID_malloc(sizeof(int *)*n_wrap); back_matches_subgroups=(match_info **)SID_malloc(sizeof(match_info *) *n_wrap); back_matches_groups =(match_info **)SID_malloc(sizeof(match_info *) *n_wrap); for(i_search=0;i_search<n_wrap;i_search++){ subgroups[i_search] =(tree_horizontal_info *)SID_calloc(sizeof(tree_horizontal_info)*n_subgroups_max); groups[i_search] =(tree_horizontal_info *)SID_calloc(sizeof(tree_horizontal_info)*n_groups_max); n_subgroups_group[i_search] =(int *)SID_calloc(sizeof(int) *n_groups_max); back_matches_subgroups[i_search]=NULL; back_matches_groups[i_search] =NULL; } SID_log("Done.",SID_LOG_CLOSE); // Process the first file separately // (just give everything ids from a running index. Also adds MMS flags.) ... init_trees_horizontal_roots(groups, subgroups, match_id, match_score, match_index, match_flag_two_way, n_particles_groups, n_particles_subgroups, n_subgroups_group, n_groups_max, n_subgroups_max, filename_root_matches, i_read_start, i_read_stop, i_read_step, i_file_start, n_wrap, n_halos_max, &max_id_group, &max_tree_id_group, &max_id_subgroup, &max_tree_id_subgroup); // The first snapshot is done now (set to defaults as the roots of trees) ... now loop over all other snapshots ... // There are a bunch of counters at work here. Because we aren't necessarily using every // snapshot (if i_read_step>1), we need counters to keep track of which snapshots we // are working with (i_read_*,j_read_*, etc), counters to keep track of which // files's we're dealing with as far as the trees indices are concerned (i_file_*,j_file_*,etc), and // counters to keep track of which files are being/have been written (i_write_*,j_write_* etc). // We can't write files right away because previously processed snapshots can be changed // when we deal with dropped and bridged halos. for(i_read =i_read_stop-i_read_step, i_file =i_file_start-1, j_file =1, i_write=i_file_start, j_write=i_read_stop, l_write=0; i_read>=i_read_start; i_read-=i_read_step, i_file--, j_file++){ SID_log("Processing snapshot #%d...",SID_LOG_OPEN|SID_LOG_TIMER,i_read); // Loop twice (1st to process subgroups, 2nd to process groups) for(k_match=0;k_match<n_k_match;k_match++){ // Initialize a bunch of stuff which depends on whether // we are processing groups or subgroups. // Do the groups first, so that we have access to n_subgroups_group, // which we need for setting MOST_MASSIVE flags, etc switch(k_match){ case 0: sprintf(group_text_prefix,""); flag_match_subgroups=MATCH_GROUPS; halos =groups; back_matches =back_matches_groups; n_halos =n_groups; n_halos_max =n_groups_max; max_id =max_id_group; max_tree_id =max_tree_id_group; n_particles =n_particles_groups; break; case 1: sprintf(group_text_prefix,"sub"); flag_match_subgroups=MATCH_SUBGROUPS; halos =subgroups; back_matches =back_matches_subgroups; n_halos =n_subgroups; n_halos_max =n_subgroups_max; max_id =max_id_subgroup; max_tree_id =max_tree_id_subgroup; n_particles =n_particles_subgroups; break; } halos_i =halos[i_file%n_wrap]; n_halos_i=n_halos[j_file]; SID_log("Processing %d %sgroups...",SID_LOG_OPEN|SID_LOG_TIMER,n_halos_i,group_text_prefix); // Initialize tree pointer-arrays with dummy values init_trees_horizontal_snapshot(halos_i, &(back_matches[i_file%n_wrap]), i_read, i_file, n_groups[j_file], n_groups_max, n_subgroups[j_file], n_subgroups_max, flag_match_subgroups); // Identify matches that will be used for progenitor building (and read halo sizes) if(flag_fix_bridges) identify_back_matches(halos, halos_i, &(back_matches[i_file%n_wrap]), n_halos_i, match_id, match_score, match_index, match_flag_two_way, n_particles, i_file, i_read, i_read_start, i_read_stop, i_read_step, n_search, n_wrap, n_halos_max, n_files, filename_root_matches, flag_match_subgroups); // Perform forward-matching identify_progenitors(halos, halos_i, n_subgroups_group, n_halos_i, match_id, match_score, match_index, match_flag_two_way, n_particles, i_file, i_read, i_read_start, i_read_stop, i_read_step, n_search, n_wrap, n_halos_max, n_files, flag_fix_bridges, &max_id, &n_halos_1_matches, &n_halos_2_matches, filename_root_matches, group_text_prefix, flag_match_subgroups); // Add MOST_MASSIVE substructure flags if(flag_match_subgroups==MATCH_SUBGROUPS) add_substructure_info(subgroups[i_file%n_wrap], n_subgroups_group[i_file%n_wrap], n_particles_groups, n_groups[j_file], n_subgroups[j_file], flag_match_subgroups); // Finalize matches to unprocessed halos. In particular, // resolve matches to bridged halos that were not matched // to any emerged candidates. finalize_trees_horizontal(n_halos_1_matches, n_halos_i, halos, halos_i, i_file, n_search, n_wrap, &max_id, &max_tree_id); // Now that we know which halos are main progenitors, we // can set the n_partices_largest_descendant values. set_largest_descendants(halos_i,n_halos_i); // Now that we know which halos are the main progenitors of this // snapshot's bridged halos, we can mark any other back matches // as candidate emerged halos and identify bridges. if(flag_fix_bridges) identify_bridges(halos_i,n_halos_i,n_search); // Report some statistics // n.b.: This is only an estimate in some cases, since subsequent snapshots may alter this snapshot. // See the final written log.txt file for accurate numbers. write_trees_horizontal_report(n_halos_i,n_halos_max,halos_i); // Update the max_id variables switch(flag_match_subgroups){ case MATCH_SUBGROUPS: max_id_subgroup=max_id; max_tree_id_subgroup=max_tree_id; break; case MATCH_GROUPS: max_id_group =max_id; max_tree_id_group=max_tree_id; break; } SID_log("Done.",SID_LOG_CLOSE); } // k_match // Write trees once a few files have been processed // and no more dropped groups etc. need to be given ids if(j_file>n_search){ int mode_write; if(flag_compute_ghosts || flag_compute_fragmented) mode_write=TREE_HORIZONTAL_WRITE_EXTENDED|TREE_HORIZONTAL_WRITE_ALLCASES|TREE_HORIZONTAL_WRITE_CHECK_FRAGMENTED; else mode_write=TREE_HORIZONTAL_WRITE_ALLCASES|TREE_HORIZONTAL_WRITE_CHECK_FRAGMENTED; write_trees_horizontal((void **)groups, (void **)subgroups, n_groups[l_write], n_groups_max, n_subgroups[l_write],n_subgroups_max, n_subgroups_group, max_tree_id_subgroup, max_tree_id_group, i_write, j_write, l_write, i_read_step, n_search, n_wrap, i_file_start, filename_cat_root_in, filename_output_dir, a_list, cosmo, n_k_match, l_write==0, mode_write); i_write--; l_write++; j_write-=i_read_step; } SID_log("Done.",SID_LOG_CLOSE); } // loop over snaps // Write the remaining snapshots for(;j_write>=i_read_start;i_write--,j_write-=i_read_step,l_write++){ int mode_write; if(flag_compute_ghosts || flag_compute_fragmented) mode_write=TREE_HORIZONTAL_WRITE_EXTENDED|TREE_HORIZONTAL_WRITE_ALLCASES|TREE_HORIZONTAL_WRITE_CHECK_FRAGMENTED; else mode_write=TREE_HORIZONTAL_WRITE_ALLCASES|TREE_HORIZONTAL_WRITE_CHECK_FRAGMENTED; write_trees_horizontal((void **)groups, (void **)subgroups, n_groups[l_write], n_groups_max, n_subgroups[l_write],n_subgroups_max, n_subgroups_group, max_tree_id_subgroup, max_tree_id_group, i_write, j_write, l_write, i_read_step, n_search, n_wrap, i_file_start, filename_cat_root_in, filename_output_dir, a_list, cosmo, n_k_match, l_write==0, mode_write); } int i_write_last; int l_write_last; int j_write_last; i_write_last=i_write+1; j_write_last=j_write+i_read_step; l_write_last=l_write-1; // Clean-up SID_log("Freeing arrays...",SID_LOG_OPEN); for(i_search=0;i_search<n_wrap;i_search++){ // Free subgroup information SID_free(SID_FARG subgroups[i_search]); SID_free(SID_FARG back_matches_subgroups[i_search]); // Free group information SID_free(SID_FARG groups[i_search]); SID_free(SID_FARG back_matches_groups[i_search]); } SID_free(SID_FARG subgroups); SID_free(SID_FARG groups); SID_free(SID_FARG back_matches_subgroups); SID_free(SID_FARG back_matches_groups); SID_free(SID_FARG match_id); SID_free(SID_FARG match_score); SID_free(SID_FARG match_index); SID_free(SID_FARG match_flag_two_way); SID_free(SID_FARG n_particles_groups); SID_free(SID_FARG n_particles_subgroups); SID_log("Done.",SID_LOG_CLOSE); // Any information that needs to be communicated up the trees from the // roots will be done here. This includes any information needed // for tracking mergers and fragmented halos. // Because fragmented halos might persist longer than the search interval, we have to // walk the trees forward in time to propagate the TREE_CASE_FRAGMENTED_* flags. // At this point, fragmented halos are only labeled when they appear. // This will propagate the fragmented halo flags forward in time. propagate_progenitor_info(n_groups, n_subgroups, n_subgroups_group, i_file_start, i_write_last, j_write_last, l_write_last, i_read_stop, i_read_step, max_tree_id_subgroup, max_tree_id_group, n_subgroups_max, n_groups_max, n_search, n_files, n_wrap, n_k_match, a_list, cosmo, filename_output_dir, flag_compute_fragmented); // If extended horizontal tree files were written for fragmented // halo propagation or ghost tree construction, remove them. if(flag_compute_ghosts || flag_compute_fragmented){ SID_log("Removing temporary tree files...",SID_LOG_OPEN); for(j_write=i_read_stop;j_write>=i_read_start;j_write-=i_read_step){ char filename_output_dir_horizontal[MAX_FILENAME_LENGTH]; char filename_output_dir_horizontal_trees[MAX_FILENAME_LENGTH]; char filename_remove[MAX_FILENAME_LENGTH]; sprintf(filename_output_dir_horizontal, "%s/horizontal",filename_output_dir); sprintf(filename_output_dir_horizontal_trees,"%s/trees", filename_output_dir_horizontal); sprintf(filename_remove,"%s/horizontal_trees_tmp_%03d.dat",filename_output_dir_horizontal_trees,j_write); remove(filename_remove); } SID_log("Done.",SID_LOG_CLOSE); } // Some final clean-up SID_log("Cleaning up...",SID_LOG_OPEN); SID_free(SID_FARG n_groups); SID_free(SID_FARG n_subgroups); for(i_search=0;i_search<n_wrap;i_search++) SID_free(SID_FARG n_subgroups_group[i_search]); SID_free(SID_FARG n_subgroups_group); SID_free(SID_FARG a_list); SID_log("Done.",SID_LOG_CLOSE); // Force the forest construction to use all snapshots int n_search_forests=i_read_stop; // Construct tree->forest mappings compute_forests(filename_output_dir,n_search_forests); SID_log("Done.",SID_LOG_CLOSE); }
void compute_treenode_list_marker_stats(tree_info *trees,treenode_list_info *list,tree_markers_info **markers_all,tree_markers_stats_info *stats,int **n_hist_count,int *n_hist){ int n_stats=3; int n_M =2; (*n_hist) =n_stats+n_M; // Allocate histogram arrays -- stats int i_hist=0; int **hist =(int **)SID_calloc(sizeof(int *)*(*n_hist)); int *n_bins=(int *)SID_calloc(sizeof(int)*(*n_hist)); for(int i_stat=0;i_stat<n_stats;i_stat++){ n_bins[i_hist]=trees->n_snaps; hist[i_hist++]=(int *)SID_calloc(sizeof(int)*n_bins[i_hist]); } // Allocate histogram arrays -- mass double logM_min=7.; int n_M_bins=90; double dlogM =0.1; for(int i_M=0;i_M<n_M;i_M++){ n_bins[i_hist]=n_M_bins; hist[i_hist++]=(int *)SID_calloc(sizeof(int)*n_bins[i_hist]); } // Allocate histogram counts if((*n_hist_count)==NULL) (*n_hist_count)=(int *)SID_calloc(sizeof(int)*(*n_hist)); else{ for(i_hist=0;i_hist<(*n_hist);i_hist++) (*n_hist_count)[i_hist]=0; } // Work with a precompiled markers array if it's been given tree_markers_info *markers; if(markers_all==NULL) markers=(tree_markers_info *)SID_malloc(sizeof(tree_markers_info)); // Create histograms for(int i_list=0;i_list<list->n_list_local;i_list++){ markers=fetch_treenode_precomputed_markers(trees,list->list[i_list]); // Build histogram int i_bin; for(int i_hist=0;i_hist<(*n_hist);i_hist++){ i_bin=-1; if(i_hist<n_stats){ tree_node_info *marker=NULL; if(i_hist==0) marker=markers->half_peak_mass; else if(i_hist==1) marker=markers->merger_33pc_remnant; else if(i_hist==2) marker=markers->merger_10pc_remnant; else SID_trap_error("Behaviour undefined in compute_treenode_list_marker_stats()",ERROR_LOGIC); if(marker!=NULL) i_bin=marker->snap_tree; else i_bin=-1; } else{ if(i_hist==(n_stats+0)){ halo_properties_info *properties=fetch_treenode_properties(trees,list->list[i_list]); i_bin=(take_log10(properties->M_vir)-logM_min)/dlogM; } else if(i_hist==(n_stats+1)) i_bin=(take_log10(markers->M_peak)-logM_min)/dlogM; else SID_trap_error("Behaviour undefined in compute_treenode_list_marker_stats()",ERROR_LOGIC); } if(i_bin>=0 && i_bin<n_bins[i_hist]){ hist[i_hist][i_bin]++; (*n_hist_count)[i_hist]++; } } } if(markers_all==NULL) SID_free(SID_FARG markers); for(int i_hist=0;i_hist<(*n_hist);i_hist++){ SID_Allreduce(SID_IN_PLACE,hist[i_hist],n_bins[i_hist],SID_INT,SID_SUM,SID.COMM_WORLD); SID_Allreduce(SID_IN_PLACE,&((*n_hist_count)[i_hist]),1,SID_INT,SID_SUM,SID.COMM_WORLD); } // Find 68 and 95 percent confidence ranges for(int i_hist=0;i_hist<(*n_hist);i_hist++){ int sum=0; for(int i_bin=0;i_bin<n_bins[i_hist];i_bin++) sum+=hist[i_hist][i_bin]; size_t *hist_index=NULL; merge_sort(hist[i_hist],(size_t)(n_bins[i_hist]),&hist_index,SID_INT,SORT_COMPUTE_INDEX,FALSE); int i_peak =hist_index[n_bins[i_hist]-1]; int i_68_lo=hist_index[n_bins[i_hist]-1]; int i_68_hi=hist_index[n_bins[i_hist]-1]; int target =(int)(0.68*(double)sum); int accum =0; int i_bin =0; while(accum<=target && i_bin<n_bins[i_hist]){ size_t idx_i=hist_index[n_bins[i_hist]-i_bin-1]; if(idx_i<i_68_lo) i_68_lo=idx_i; if(idx_i>i_68_hi) i_68_hi=idx_i; accum+=hist[i_hist][idx_i]; i_bin++; } int i_95_lo=i_68_lo; int i_95_hi=i_68_hi; target=(int)(0.95*(double)sum); while(accum<=target && i_bin<n_bins[i_hist]){ size_t idx_i=hist_index[n_bins[i_hist]-i_bin-1]; if(idx_i<i_95_lo) i_95_lo=idx_i; if(idx_i>i_95_hi) i_95_hi=idx_i; accum+=hist[i_hist][idx_i]; i_bin++; } SID_free(SID_FARG hist_index); if(i_hist==0){ stats->t_half_peak_mass_ranges[0][0]=trees->t_list[i_68_lo]; stats->t_half_peak_mass_ranges[0][1]=trees->t_list[i_68_hi]; stats->t_half_peak_mass_ranges[1][0]=trees->t_list[i_95_lo]; stats->t_half_peak_mass_ranges[1][1]=trees->t_list[i_95_hi]; stats->t_half_peak_mass_peak =trees->t_list[i_peak]; } else if(i_hist==1){ stats->t_merger_33pc_ranges[0][0]=trees->t_list[i_68_lo]; stats->t_merger_33pc_ranges[0][1]=trees->t_list[i_68_hi]; stats->t_merger_33pc_ranges[1][0]=trees->t_list[i_95_lo]; stats->t_merger_33pc_ranges[1][1]=trees->t_list[i_95_hi]; stats->t_merger_33pc_peak =trees->t_list[i_peak]; } else if(i_hist==2){ stats->t_merger_10pc_ranges[0][0]=trees->t_list[i_68_lo]; stats->t_merger_10pc_ranges[0][1]=trees->t_list[i_68_hi]; stats->t_merger_10pc_ranges[1][0]=trees->t_list[i_95_lo]; stats->t_merger_10pc_ranges[1][1]=trees->t_list[i_95_hi]; stats->t_merger_10pc_peak =trees->t_list[i_peak]; } else if(i_hist==3){ stats->M_peak_ranges[0][0]=logM_min+(double)(i_68_lo)*dlogM; stats->M_peak_ranges[0][1]=logM_min+(double)(i_68_hi)*dlogM; stats->M_peak_ranges[1][0]=logM_min+(double)(i_95_lo)*dlogM; stats->M_peak_ranges[1][1]=logM_min+(double)(i_95_hi)*dlogM; stats->M_peak_peak =logM_min+(double)( i_peak)*dlogM; } else if(i_hist==4){ stats->M_vir_ranges[0][0]=logM_min+(double)(i_68_lo)*dlogM; stats->M_vir_ranges[0][1]=logM_min+(double)(i_68_hi)*dlogM; stats->M_vir_ranges[1][0]=logM_min+(double)(i_95_lo)*dlogM; stats->M_vir_ranges[1][1]=logM_min+(double)(i_95_hi)*dlogM; stats->M_vir_peak =logM_min+(double)( i_peak)*dlogM; } else SID_trap_error("Behaviour undefined in compute_treenode_list_marker_stats()",ERROR_LOGIC); } // Clean-up for(int i_hist=0;i_hist<(*n_hist);i_hist++) SID_free(SID_FARG hist[i_hist]); SID_free(SID_FARG hist); SID_free(SID_FARG n_bins); }
void init_MCMC(MCMC_info * MCMC, const char *problem_name, void * params, int (*f)(double *, MCMC_info *, double **), int n_P, double *P_init, char ** P_names, double *P_limit_min, double *P_limit_max, int n_arrays, ...) { int i_P; int i_array; int i; FILE * ft, *ft_restart; char test_dir[256], test_restart[256]; va_list vargs; va_start(vargs, n_arrays); SID_log("Initializing MCMC structure...", SID_LOG_OPEN); // Set defaults to bare minimums MCMC->n_avg = 100; MCMC->n_iterations_burn = 4; MCMC->n_iterations = 8; MCMC->n_thin = 1; MCMC->coverage_size = 100; MCMC->flag_autocor_on = GBP_FALSE; MCMC->flag_integrate_on = GBP_FALSE; MCMC->flag_analysis_on = GBP_TRUE; MCMC->first_map_call = GBP_TRUE; MCMC->first_link_call = GBP_TRUE; MCMC->flag_init_chain = GBP_TRUE; MCMC->first_chain_call = GBP_TRUE; MCMC->first_parameter_call = GBP_TRUE; MCMC->first_likelihood_call = GBP_TRUE; MCMC->ln_likelihood_last = 0.; MCMC->ln_likelihood_new = 0.; MCMC->ln_likelihood_chain = 0.; MCMC->P_init = NULL; MCMC->P_new = NULL; MCMC->P_last = NULL; MCMC->P_chain = NULL; MCMC->P_limit_min = NULL; MCMC->P_limit_max = NULL; MCMC->P_min = NULL; MCMC->P_max = NULL; MCMC->P_avg = NULL; MCMC->dP_avg = NULL; MCMC->P_best = NULL; MCMC->P_peak = NULL; MCMC->P_lo_68 = NULL; MCMC->P_hi_68 = NULL; MCMC->P_lo_95 = NULL; MCMC->P_hi_95 = NULL; MCMC->n_M = NULL; MCMC->M_new = NULL; MCMC->M_last = NULL; MCMC->DS = NULL; MCMC->last = NULL; MCMC->V = NULL; MCMC->m = NULL; MCMC->b = NULL; MCMC->RNG = NULL; MCMC->params = NULL; MCMC->temperature = 1.0; MCMC->n_DS = 0; MCMC->n_M_total = 0; MCMC->n_fail = 0; MCMC->n_success = 0; MCMC->n_propositions = 0; MCMC->n_map_calls = 0; // Process the passed arguments MCMC->map_P_to_M = f; MCMC->compute_MCMC_ln_likelihood = compute_MCMC_ln_likelihood_default; MCMC->params = params; MCMC->n_P = n_P; sprintf(MCMC->problem_name, "%s", problem_name); MCMC->P_names = (char **)SID_malloc(sizeof(char *) * MCMC->n_P); MCMC->P_name_length = 0; for(i_P = 0; i_P < n_P; i_P++) { MCMC->P_names[i_P] = (char *)SID_malloc(sizeof(char) * MCMC_NAME_SIZE); sprintf(MCMC->P_names[i_P], "%s", P_names[i_P]); MCMC->P_name_length = GBP_MAX((size_t)(MCMC->P_name_length), strlen(MCMC->P_names[i_P])); } sprintf(MCMC->P_name_format, "%%-%ds", MCMC->P_name_length); // Initialize the MCMC mode and set things associated with it set_MCMC_mode(MCMC, MCMC_MODE_DEFAULT); // MCMC->my_chain is set here // Set parameter arrays and limits MCMC->P_init = (double *)SID_malloc(sizeof(double) * MCMC->n_P); MCMC->P_new = (double *)SID_malloc(sizeof(double) * MCMC->n_P); MCMC->P_last = (double *)SID_malloc(sizeof(double) * MCMC->n_P); MCMC->P_chain = (double *)SID_malloc(sizeof(double) * MCMC->n_P); MCMC->P_limit_min = (double *)SID_malloc(sizeof(double) * MCMC->n_P); MCMC->P_limit_max = (double *)SID_malloc(sizeof(double) * MCMC->n_P); if(P_limit_min == NULL) { for(i_P = 0; i_P < n_P; i_P++) MCMC->P_limit_min[i_P] = -DBL_MAX * 1e-3; } else { for(i_P = 0; i_P < n_P; i_P++) MCMC->P_limit_min[i_P] = P_limit_min[i_P]; } if(P_limit_max == NULL) { for(i_P = 0; i_P < n_P; i_P++) MCMC->P_limit_max[i_P] = DBL_MAX * 1e-3; } else { for(i_P = 0; i_P < n_P; i_P++) MCMC->P_limit_max[i_P] = P_limit_max[i_P]; } // Set parameter initial values memcpy(MCMC->P_init, P_init, (size_t)MCMC->n_P * sizeof(double)); memcpy(MCMC->P_new, P_init, (size_t)MCMC->n_P * sizeof(double)); memcpy(MCMC->P_last, P_init, (size_t)MCMC->n_P * sizeof(double)); memcpy(MCMC->P_chain, P_init, (size_t)MCMC->n_P * sizeof(double)); // Set arrays MCMC->n_arrays = n_arrays; if(n_arrays > 0) { MCMC->array = (double **)SID_malloc(sizeof(double *) * MCMC->n_arrays); MCMC->array_name = (char **)SID_malloc(sizeof(char *) * MCMC->n_arrays); for(i_array = 0; i_array < n_arrays; i_array++) { MCMC->array[i_array] = (double *)SID_malloc(sizeof(double) * MCMC->n_P); MCMC->array_name[i_array] = (char *)SID_malloc(sizeof(char) * MCMC_NAME_SIZE); memcpy(MCMC->array[i_array], (double *)va_arg(vargs, double *), (size_t)(MCMC->n_P) * sizeof(double)); sprintf(MCMC->array_name[i_array], "%s", (char *)va_arg(vargs, char *)); } } else
void write_match_results(char * filename_out_dir, char * filename_out_root, int i_read, int j_read, const char *filename_cat1, const char *filename_cat2, plist_info *plist1, plist_info *plist2, int k_match, float match_weight_rank_index, int mode) { char filename_out[256]; char filename_out_dir_snap[256]; FILE * fp_out; int k_read, l_read; int flag_go; int i_read_start_file; int i_read_stop_file; int i_read_step_file; int n_search_file; int n_search_total; int n_k_match; int flag_match_subgroups; char group_text_prefix[5]; int n_matches; int n_files; int n_groups_1; int n_groups_1_local; int n_groups_2; int n_groups_2_local; int i_group; int buffered_count; int buffered_count_local; int j_group; int index_test; int i_rank; int * n_particles; int * n_sub_group; int * file_index_1; int * match_id = NULL; float * match_score = NULL; int * match_count = NULL; char cat_name_1[20]; char cat_name_2[20]; size_t *match_rank = NULL; size_t *match_index = NULL; size_t offset; int * n_return; void * buffer; int * buffer_int; size_t *buffer_size_t; float * buffer_float; int n_buffer_max = 131072; // 32*32k=1MB for 8-byte values int n_buffer; int i_buffer; int j_buffer; switch(k_match) { case 0: flag_match_subgroups = MATCH_SUBGROUPS; sprintf(group_text_prefix, "sub"); break; case 1: flag_match_subgroups = MATCH_GROUPS; sprintf(group_text_prefix, ""); break; } // Intialize filenames if(SID_CHECK_BITFIELD_SWITCH(mode, WRITE_MATCHES_MODE_TREES)) { sprintf(filename_out_dir_snap, "%s/%s", filename_out_dir, filename_cat1); // Create output directory if need-be if(filename_out_dir != NULL) mkdir(filename_out_dir, 02755); } else if(SID_CHECK_BITFIELD_SWITCH(mode, WRITE_MATCHES_MODE_SINGLE)) sprintf(filename_out_dir_snap, "%s/", filename_out_dir); else SID_exit_error("Invalid write mode flag (%d).", SID_ERROR_LOGIC, mode); if(filename_out_dir != NULL) sprintf(filename_out, "%s/%sgroup_matches_%s_%s.dat", filename_out_dir_snap, group_text_prefix, filename_cat1, filename_cat2); else sprintf(filename_out, "%s_%sgroup_matches_%s_%s.dat", filename_out_root, group_text_prefix, filename_cat1, filename_cat2); SID_log("Writing match results to {%s}...", SID_LOG_OPEN | SID_LOG_TIMER, filename_out); // Fetch halo counts ... n_groups_1 = ((int *)ADaPS_fetch(plist1->data, "n_%sgroups_all_%s", group_text_prefix, filename_cat1))[0]; n_groups_2 = ((int *)ADaPS_fetch(plist2->data, "n_%sgroups_all_%s", group_text_prefix, filename_cat2))[0]; // Write header. if(SID.I_am_Master) { if(filename_out_dir != NULL) mkdir(filename_out_dir_snap, 02755); if((fp_out = fopen(filename_out, "w")) == NULL) SID_exit_error("Could not open {%s} for writing.", SID_ERROR_IO_OPEN, filename_out); fwrite(&i_read, sizeof(int), 1, fp_out); fwrite(&j_read, sizeof(int), 1, fp_out); fwrite(&n_groups_1, sizeof(int), 1, fp_out); fwrite(&n_groups_2, sizeof(int), 1, fp_out); fwrite(&match_weight_rank_index, sizeof(float), 1, fp_out); } // Everything else only needs to be written if there are halos to match with if(n_groups_1 > 0) { // Fetch catalog and matching info ... n_groups_1_local = ((int *)ADaPS_fetch(plist1->data, "n_%sgroups_%s", group_text_prefix, filename_cat1))[0]; file_index_1 = (int *)ADaPS_fetch(plist1->data, "file_index_%sgroups_%s", group_text_prefix, filename_cat1); n_groups_2_local = ((int *)ADaPS_fetch(plist2->data, "n_%sgroups_%s", group_text_prefix, filename_cat2))[0]; match_id = (int *)ADaPS_fetch(plist1->data, "match_match"); match_score = (float *)ADaPS_fetch(plist1->data, "match_score_match"); match_count = (int *)ADaPS_fetch(plist1->data, "match_count_match"); // Generate ranking of matches sort(match_id, (size_t)n_groups_1_local, &match_index, SID_INT, SORT_GLOBAL, SORT_COMPUTE_INDEX, SORT_COMPUTE_NOT_INPLACE); sort(match_index, (size_t)n_groups_1_local, &match_rank, SID_SIZE_T, SORT_GLOBAL, SORT_COMPUTE_INDEX, SORT_COMPUTE_NOT_INPLACE); SID_free(SID_FARG match_index); // Now we write the matching results. We need to write back to the file in the // order that it was read from the halo catalogs, not necessarily the PH order // that it is stored in RAM. This requires some buffer trickery. buffer = SID_malloc(n_buffer_max * sizeof(size_t)); buffer_int = (int *)buffer; buffer_size_t = (size_t *)buffer; buffer_float = (float *)buffer; // Write match_ids ... // ... loop over all the groups in buffer-sized batches SID_log("Writing match IDs...", SID_LOG_OPEN | SID_LOG_TIMER); for(i_group = 0, buffered_count_local = 0; i_group < n_groups_1; i_group += n_buffer) { // Decide this buffer iteration's size n_buffer = GBP_MIN(n_buffer_max, n_groups_1 - i_group); // Set the buffer to a default value smaller than the smallest possible data size for(i_buffer = 0; i_buffer < n_buffer; i_buffer++) buffer_int[i_buffer] = -2; // Min value of match_id is -1 // Determine if any of the local data is being used for this buffer for(j_group = 0; j_group < n_groups_1_local; j_group++) { index_test = file_index_1[j_group] - i_group; // ... if so, set the appropriate buffer value if(index_test >= 0 && index_test < n_buffer) { buffer_int[index_test] = match_id[j_group]; buffered_count_local++; } } // Doing a global max on the buffer yields the needed buffer on all ranks SID_Allreduce(SID_IN_PLACE, buffer_int, n_buffer, SID_INT, SID_MAX, SID_COMM_WORLD); if(SID.I_am_Master) { // Sanity check for(i_buffer = 0; i_buffer < n_buffer; i_buffer++) { if(buffer_int[i_buffer] < -1 || buffer_int[i_buffer] >= n_groups_2) SID_exit_error( "Illegal match_id result (%d) for group No. %d. There are %d groups in the target catalog.", SID_ERROR_LOGIC, buffer_int[i_buffer], i_group + i_buffer, n_groups_2); } // Write the buffer fwrite(buffer_int, sizeof(int), (size_t)n_buffer, fp_out); } } // Sanity check calc_sum_global(&buffered_count_local, &buffered_count, 1, SID_INT, CALC_MODE_DEFAULT, SID_COMM_WORLD); if(buffered_count != n_groups_1) SID_exit_error("Buffer counts don't make sense (ie %d!=%d) after writing match IDs.", SID_ERROR_LOGIC, buffered_count, n_groups_1); SID_log("Done.", SID_LOG_CLOSE); // Write match_score ... // ... loop over all the groups in buffer-sized batches SID_log("Writing match scores...", SID_LOG_OPEN | SID_LOG_TIMER); for(i_group = 0, buffered_count_local = 0; i_group < n_groups_1; i_group += n_buffer) { // Decide this buffer iteration's size n_buffer = GBP_MIN(n_buffer_max, n_groups_1 - i_group); // Set the buffer to a default value smaller than the smallest possible data size for(i_buffer = 0; i_buffer < n_buffer; i_buffer++) buffer_float[i_buffer] = -1.; // Min value of match_score is 0. // Determine if any of the local data is being used for this buffer for(j_group = 0; j_group < n_groups_1_local; j_group++) { index_test = file_index_1[j_group] - i_group; // ... if so, set the appropriate buffer value if(index_test >= 0 && index_test < n_buffer) { buffer_float[index_test] = match_score[j_group]; buffered_count_local++; } } // Doing a global max on the buffer yields the needed buffer on all ranks SID_Allreduce(SID_IN_PLACE, buffer_float, n_buffer, SID_FLOAT, SID_MAX, SID_COMM_WORLD); if(SID.I_am_Master) { // Sanity check for(i_buffer = 0; i_buffer < n_buffer; i_buffer++) { if(buffer_float[i_buffer] < 0.) SID_exit_error("Illegal match_score result (%f) for group No. %d.", SID_ERROR_LOGIC, buffer_float[i_buffer], i_group + i_buffer); } // Write the buffer fwrite(buffer, sizeof(float), (size_t)n_buffer, fp_out); } } // Sanity check calc_sum_global(&buffered_count_local, &buffered_count, 1, SID_INT, CALC_MODE_DEFAULT, SID_COMM_WORLD); if(buffered_count != n_groups_1) SID_exit_error("Buffer counts don't make sense (ie %d!=%d) after writing match scores.", SID_ERROR_LOGIC, buffered_count, n_groups_1); SID_log("Done.", SID_LOG_CLOSE); // Write match_count ... // ... loop over all the groups in buffer-sized batches SID_log("Writing match counts...", SID_LOG_OPEN | SID_LOG_TIMER); for(i_group = 0, buffered_count_local = 0; i_group < n_groups_1; i_group += n_buffer) { // Decide this buffer iteration's size n_buffer = GBP_MIN(n_buffer_max, n_groups_1 - i_group); // Set the buffer to a default value smaller than the smallest possible data size for(i_buffer = 0; i_buffer < n_buffer; i_buffer++) buffer_int[i_buffer] = -1; // Min value of match_count is 0. // Determine if any of the local data is being used for this buffer for(j_group = 0; j_group < n_groups_1_local; j_group++) { index_test = file_index_1[j_group] - i_group; // ... if so, set the appropriate buffer value if(index_test >= 0 && index_test < n_buffer) { buffer_int[index_test] = match_count[j_group]; buffered_count_local++; } } // Doing a global max on the buffer yields the needed buffer on all ranks SID_Allreduce(SID_IN_PLACE, buffer_int, n_buffer, SID_INT, SID_MAX, SID_COMM_WORLD); if(SID.I_am_Master) { // Sanity check for(i_buffer = 0; i_buffer < n_buffer; i_buffer++) { if(buffer_int[i_buffer] < 0.) SID_exit_error("Illegal match_count result (%f) for group No. %d.", SID_ERROR_LOGIC, buffer_int[i_buffer], i_group + i_buffer); } // Write the buffer fwrite(buffer, sizeof(int), (size_t)n_buffer, fp_out); } } // Sanity check calc_sum_global(&buffered_count_local, &buffered_count, 1, SID_INT, CALC_MODE_DEFAULT, SID_COMM_WORLD); if(buffered_count != n_groups_1) SID_exit_error("Buffer counts don't make sense (ie %d!=%d) after writing match scores.", SID_ERROR_LOGIC, buffered_count, n_groups_1); SID_log("Done.", SID_LOG_CLOSE); // Clean-up SID_log("Cleaning-up...", SID_LOG_OPEN); SID_free(SID_FARG buffer); SID_free(SID_FARG match_rank); SID_log("Done.", SID_LOG_CLOSE); } // Close the file if(SID.I_am_Master) fclose(fp_out); SID_log("Done.", SID_LOG_CLOSE); }
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(); }
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[]) { int n_search; int i_halo; char filename_in[SID_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 * n_particles_i; int * n_particles_j; int j_read; int mode; int n_groups_i; int n_groups_j; int j_halo; int i_read; int i_read_start; int i_read_stop; SID_fp fp_in; SID_Init(&argc, &argv, NULL); // Fetch user inputs char filename_root_in[SID_MAX_FILENAME_LENGTH]; char filename_catalog_root[SID_MAX_FILENAME_LENGTH]; char filename_halo_version[SID_MAX_FILENAME_LENGTH]; strcpy(filename_root_in, argv[1]); strcpy(filename_halo_version, argv[2]); if(!strcmp(argv[3], "groups") || !strcmp(argv[3], "group")) mode = MATCH_GROUPS; else if(!strcmp(argv[3], "subgroups") || !strcmp(argv[3], "subgroup")) mode = MATCH_SUBGROUPS; else { SID_exit_error("Invalid mode selection {%s}. Should be 'group' or 'subgroup'.", SID_ERROR_SYNTAX, argv[3]); } i_read = atoi(argv[4]); j_read = atoi(argv[5]); int flag_SSimPL_base = GBP_TRUE; if(argc == 7) { flag_SSimPL_base = GBP_FALSE; strcpy(filename_catalog_root, argv[6]); sprintf(filename_catalog_root, "%s/halos/%s", argv[6], filename_halo_version); } else sprintf(filename_catalog_root, "%s/halos/%s", filename_root_in, filename_halo_version); SID_log("Searching match information for halo #%d in file #%d of {%s}...", SID_LOG_OPEN | SID_LOG_TIMER, i_halo, i_read, filename_root_in); // 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[SID_MAX_FILENAME_LENGTH]; if(flag_SSimPL_base) sprintf(filename_root, "%s/trees/matches/%03d/", filename_root_in, i_read); else sprintf(filename_root, "%s_", filename_root_in); // Read header information int i_read_in; int j_read_in; int n_groups_1; int n_groups_2; float score_rank_index; sprintf(filename_in, "%s%sgroup_matches_%03d_%03d.dat", filename_root, group_text_prefix, i_read, j_read); SID_fopen(filename_in, "r", &fp_in); SID_fread(&i_read_in, sizeof(int), 1, &fp_in); SID_log("i_read =%d", SID_LOG_COMMENT, i_read_in); SID_fread(&j_read_in, sizeof(int), 1, &fp_in); SID_log("j_read =%d", SID_LOG_COMMENT, j_read_in); SID_fread(&n_groups_i, sizeof(int), 1, &fp_in); SID_log("n_groups_i=%d", SID_LOG_COMMENT, n_groups_i); SID_fread(&n_groups_j, sizeof(int), 1, &fp_in); SID_log("n_groups_j=%d", SID_LOG_COMMENT, n_groups_j); SID_fread(&score_rank_index, sizeof(int), 1, &fp_in); SID_log("score_idx =%f", SID_LOG_COMMENT, score_rank_index); // Allocate RAM int * match = (int *)SID_malloc(sizeof(int) * n_groups_i); float *score = (float *)SID_malloc(sizeof(float) * n_groups_i); int * count = (int *)SID_malloc(sizeof(int) * n_groups_i); // Read arrays SID_fread(match, sizeof(int), n_groups_i, &fp_in); SID_fread(score, sizeof(float), n_groups_i, &fp_in); SID_fread(count, sizeof(int), n_groups_i, &fp_in); // Close file SID_fclose(&fp_in); // Read halo sizes from header file SID_log("Reading halo sizes...", SID_LOG_OPEN); int *n_p_i = (int *)SID_malloc(sizeof(int) * n_groups_i); sprintf(filename_in, "%s_%03d.catalog_%sgroups", filename_catalog_root, i_read, group_text_prefix); SID_fopen(filename_in, "r", &fp_in); int n_cat_i; int offset_size_i; SID_fread(&n_cat_i, sizeof(int), 1, &fp_in); SID_fread(&offset_size_i, sizeof(int), 1, &fp_in); if(n_cat_i != n_groups_i) SID_exit_error("Catalog 'i' halo counts don't match (ie %d!=%d)", SID_ERROR_LOGIC, n_cat_i, n_groups_i); SID_fread(n_p_i, sizeof(int), n_cat_i, &fp_in); SID_fclose(&fp_in); int *n_p_j = (int *)SID_malloc(sizeof(int) * n_groups_j); sprintf(filename_in, "%s_%03d.catalog_%sgroups", filename_catalog_root, j_read, group_text_prefix); SID_fopen(filename_in, "r", &fp_in); int n_cat_j; int offset_size_j; SID_fread(&n_cat_j, sizeof(int), 1, &fp_in); SID_fread(&offset_size_j, sizeof(int), 1, &fp_in); if(n_cat_j != n_groups_j) SID_exit_error("Catalog 'i' halo counts don't match (ie %d!=%d)", SID_ERROR_LOGIC, n_cat_j, n_groups_j); SID_fread(n_p_j, sizeof(int), n_cat_j, &fp_in); SID_fclose(&fp_in); SID_log("Done.", SID_LOG_CLOSE); // Print results for(k_read = 0; k_read < n_groups_i; k_read++) { if(match[k_read] >= 0) printf("%7d %7d %7d %7d %7d %le %le %le\n", k_read, match[k_read], n_p_i[k_read], n_p_j[match[k_read]], count[k_read], score[k_read], maximum_match_score(n_p_i[k_read]), match_score_f_goodness(score[k_read], n_p_i[k_read])); } // Clean-up SID_free(SID_FARG match); SID_free(SID_FARG score); SID_free(SID_FARG count); SID_free(SID_FARG n_p_i); SID_free(SID_FARG n_p_j); SID_log("Done.", SID_LOG_CLOSE); SID_Finalize(); }
void SID_init(int *argc, char **argv[], SID_args args[], void *mpi_comm_as_void){ int status; int i_level; int i_char; int flag_continue; int flag_passed_comm; // MPI-specific things #if USE_MPI int n_keys; int i_key; char key[256]; char key_value[256]; int key_exists; char nodes_string[256]; SID_fp fp_tmp; FILE *fp_hack; int node_name_length; MPI_Comm mpi_comm; #if USE_MPI_IO MPI_Info info_disp; #endif if (mpi_comm_as_void == NULL) { flag_passed_comm = 0; MPI_Init(argc,argv); MPI_Comm_dup(MPI_COMM_WORLD, &mpi_comm); } else { mpi_comm = *((MPI_Comm *) mpi_comm_as_void); flag_passed_comm = 1; } MPI_Comm_size(mpi_comm, &(SID.n_proc)); MPI_Comm_rank(mpi_comm, &(SID.My_rank)); SID.My_node =(char *)SID_malloc(SID_MAXLENGTH_PROCESSOR_NAME * sizeof(char)); #if USE_MPI MPI_Get_processor_name(SID.My_node, &node_name_length); #else sprintf(SID.My_node,"localhost"); node_name_length=strlen(SID.My_node); #endif if (node_name_length >= SID_MAXLENGTH_PROCESSOR_NAME-1) SID_trap_error("SID_MAXLENGTH_PROCESSOR_NAME needs to be increased",ERROR_LOGIC); // Make my_rank=MASTER_RANK the master if(SID.My_rank==MASTER_RANK) SID.I_am_Master=TRUE; else SID.I_am_Master=FALSE; // Identify the last rank if(SID.My_rank==SID.n_proc-1) SID.I_am_last_rank=TRUE; else SID.I_am_last_rank=FALSE; #if USE_MPI_IO // Fetch collective buffering defaults MPI_Info_create(&(SID.file_info)); if(SID.I_am_Master){ fp_hack=fopen(".tmp.SID","w+"); fclose(fp_hack); } MPI_Barrier(mpi_comm); MPI_File_open(mpi_comm, ".tmp.SID", MPI_MODE_WRONLY, MPI_INFO_NULL, &(fp_tmp.fp)); MPI_File_get_info(fp_tmp.fp,&info_disp); MPI_Info_get_nkeys(info_disp,&n_keys); for(i_key=0;i_key<n_keys;i_key++){ MPI_Info_get_nthkey(info_disp,i_key,key); MPI_Info_get(info_disp,key,MPI_MAX_INFO_VAL,key_value,&key_exists); if(key_exists) MPI_Info_set((SID.file_info),key,key_value); } MPI_File_close(&(fp_tmp.fp)); if(SID.I_am_Master) remove(".tmp.SID"); // Set user-defined colective buffering optimizations sprintf(nodes_string,"%d",MIN(SID.n_proc,N_IO_FILES_MAX)); MPI_Info_set((SID.file_info),"cb_nodes", nodes_string); MPI_Info_set((SID.file_info),"cb_config_list", "*:1"); #endif #else SID.My_rank=MASTER_RANK; SID.n_proc =1; #endif /* #if !USE_MPI_IO SID.n_groups=SID.n_proc/N_IO_FILES_MAX; if(SID.n_proc%N_IO_FILES_MAX) SID.n_groups++; SID.My_group=SID.My_rank/N_IO_FILES_MAX; #endif */ // Set ranks to the left and right SID.rank_to_right =(SID.My_rank+1)%SID.n_proc; SID.rank_to_left = SID.My_rank-1; if(SID.rank_to_left<0) SID.rank_to_left = SID.n_proc-1; // Intitialize log timing information SID.time_start_level=(time_t *)SID_malloc(sizeof(time_t)*SID_LOG_MAX_LEVELS); SID.time_stop_level =(time_t *)SID_malloc(sizeof(time_t)*SID_LOG_MAX_LEVELS); SID.time_total_level=(int *)SID_malloc(sizeof(int) *SID_LOG_MAX_LEVELS); SID.IO_size =(double *)SID_malloc(sizeof(double)*SID_LOG_MAX_LEVELS); SID.flag_use_timer =(int *)SID_malloc(sizeof(int) *SID_LOG_MAX_LEVELS); for(i_level=0;i_level<SID_LOG_MAX_LEVELS;i_level++){ SID.time_start_level[i_level]=0; SID.time_stop_level[i_level] =0; SID.time_total_level[i_level]=0; SID.IO_size[i_level] =0.; SID.flag_use_timer[i_level] =FALSE; } // Initialize other log information #if USE_MPI if(*argc>1) SID.fp_in =fopen((*argv)[1],"r"); else SID.fp_in =NULL; #else SID.fp_in =stdin; #endif if (flag_passed_comm) SID.fp_log = NULL; else SID.fp_log = stderr; SID.level =0; SID.indent =TRUE; SID.awake =TRUE; SID.flag_results_on=FALSE; SID.verbosity =SID_LOG_MAX_LEVELS; // Store the name of the binary executable that brought us here strcpy(SID.My_binary,(*argv)[0]); strip_path(SID.My_binary); // Initialize argument information if(args!=NULL){ if((status=SID_parse_args(*argc,*argv,args))>0){ SID_print_syntax(*argc,*argv,args); SID_exit(status); } } else SID.args=NULL; #if USE_MPI_IO if(SID.I_am_Master){ fp_hack=fopen(".tmp.SID","w+"); fclose(fp_hack); } MPI_Barrier(mpi_comm); SID_fopen(".tmp.SID","w",&fp_tmp); MPI_File_get_info(fp_tmp.fp,&info_disp); if(SID.I_am_Master){ fprintf(stdout,"\n"); fprintf(stdout,"MPI-I/O Configuration:\n"); fprintf(stdout,"---------------------\n"); MPI_Info_get_nkeys(info_disp,&n_keys); for(i_key=0;i_key<n_keys;i_key++){ MPI_Info_get_nthkey(info_disp,i_key,key); MPI_Info_get(info_disp,key,MPI_MAX_INFO_VAL,key_value,&key_exists); if(key_exists) fprintf(stdout,"key %2d of %d: {%s}={%s}\n",i_key+1,n_keys,key,key_value); } fprintf(stdout,"\n"); } SID_fclose(&fp_tmp); if(SID.I_am_Master) remove(".tmp.SID"); #else #if USE_MPI if(SID.I_am_Master) fprintf(stdout,"MPI-I/O switched off.\n\n"); #endif #endif // Create private COMM_WORLD SID_Comm_init(&(SID.COMM_WORLD)); #if USE_MPI MPI_Comm_dup(mpi_comm, &((SID.COMM_WORLD)->comm)); MPI_Comm_group((SID.COMM_WORLD)->comm,&((SID.COMM_WORLD)->group)); MPI_Comm_size(SID.COMM_WORLD->comm, &((SID.COMM_WORLD)->n_proc)); MPI_Comm_rank(SID.COMM_WORLD->comm, &((SID.COMM_WORLD)->My_rank)); // We have duplicated our duplicate mpi communicator - now we can free the // original duplicate MPI_Comm_free(&mpi_comm); #else SID.COMM_WORLD->comm =NULL; SID.COMM_WORLD->group =NULL; SID.COMM_WORLD->n_proc =1; SID.COMM_WORLD->My_rank=MASTER_RANK; #endif // Start total-run-ime timer (void)time(&(SID.time_start)); // Default max wallclock SID.max_wallclock=DEFAULT_MAX_WALLCLOCK_TIME; }
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); }
void average_tree_branches(const char *catalog_name){ SID_log("Processing tree tracks in catalog {%s}...",SID_LOG_OPEN,catalog_name); // Master Rank does all the work FILE *fp_tracks_in=NULL; if(SID.I_am_Master){ // Create and open the output files char filename_tracks_in[MAX_FILENAME_LENGTH]; sprintf(filename_tracks_in,"%s_tracks.dat",catalog_name); SID_log("Processing {%s}...",SID_LOG_OPEN,filename_tracks_in); fp_tracks_in=fopen(filename_tracks_in,"r"); // Write header for tracks file int n_list; int n_snaps; fread_verify(&n_list, sizeof(int),1,fp_tracks_in); fread_verify(&n_snaps,sizeof(int),1,fp_tracks_in); int *snap_list=(int *)SID_malloc(sizeof(int) *n_snaps); double *z_list =(double *)SID_malloc(sizeof(double)*n_snaps); double *t_list =(double *)SID_malloc(sizeof(double)*n_snaps); fread_verify(snap_list,sizeof(int), n_snaps,fp_tracks_in); fread_verify(z_list, sizeof(double),n_snaps,fp_tracks_in); fread_verify(t_list, sizeof(double),n_snaps,fp_tracks_in); // Allocate some temporary arrays for the tracks double M_min = 6.; double M_max =16.; int n_M_bins=200; double dM =(M_max-M_min)/(double)n_M_bins; double inv_dM =1./dM; int **M_hist =(int **)SID_malloc(sizeof(int *)*n_snaps); for(int i_snap=0;i_snap<n_snaps;i_snap++) M_hist[i_snap]=(int *)SID_calloc(sizeof(int)*n_M_bins); int *i_z_track=(int *)SID_malloc(sizeof(int)*n_snaps);; int *idx_track=(int *)SID_malloc(sizeof(int)*n_snaps);; double *M_track =(double *)SID_malloc(sizeof(double)*n_snaps); double *x_track =(double *)SID_malloc(sizeof(double)*n_snaps); double *y_track =(double *)SID_malloc(sizeof(double)*n_snaps); double *z_track =(double *)SID_malloc(sizeof(double)*n_snaps); double *vx_track =(double *)SID_malloc(sizeof(double)*n_snaps); double *vy_track =(double *)SID_malloc(sizeof(double)*n_snaps); double *vz_track =(double *)SID_malloc(sizeof(double)*n_snaps); // Process each track in turn for(int i_list=0;i_list<n_list;i_list++){ int n_track; // Read track fread_verify(&n_track, sizeof(int), 1, fp_tracks_in); fread_verify(i_z_track,sizeof(int), n_track,fp_tracks_in); fread_verify(idx_track,sizeof(int), n_track,fp_tracks_in); fread_verify(x_track, sizeof(double),n_track,fp_tracks_in); fread_verify(y_track, sizeof(double),n_track,fp_tracks_in); fread_verify(z_track, sizeof(double),n_track,fp_tracks_in); fread_verify(vx_track, sizeof(double),n_track,fp_tracks_in); fread_verify(vy_track, sizeof(double),n_track,fp_tracks_in); fread_verify(vz_track, sizeof(double),n_track,fp_tracks_in); fread_verify(M_track, sizeof(double),n_track,fp_tracks_in); // Build the M-histograms for(int i_track=0;i_track<n_track;i_track++){ int i_bin=(int)((take_log10(M_track[i_track])-M_min)*inv_dM); if(i_bin>=0 && i_bin<n_M_bins) M_hist[i_z_track[i_track]][i_bin]++; } } // for i_list fclose(fp_tracks_in); // Build confidence intervals for M-track int *n_i =(int *)SID_calloc(sizeof(int)*n_snaps); double *M_peak =(double *)SID_calloc(sizeof(double)*n_snaps); double *M_68_lo=(double *)SID_calloc(sizeof(double)*n_snaps); double *M_68_hi=(double *)SID_calloc(sizeof(double)*n_snaps); for(int i_snap=0;i_snap<n_snaps;i_snap++){ size_t *M_hist_index=NULL; for(int i_bin=0;i_bin<n_M_bins;i_bin++) n_i[i_snap]+=M_hist[i_snap][i_bin]; if(n_i[i_snap]>0){ merge_sort(M_hist[i_snap],(size_t)n_M_bins,&M_hist_index,SID_INT,SORT_COMPUTE_INDEX,FALSE); int i_peak =M_hist_index[n_M_bins-1]; int i_68_lo=M_hist_index[n_M_bins-1]; int i_68_hi=M_hist_index[n_M_bins-1]; int target =(int)(0.68*(double)n_i[i_snap]); int accum =0; int i_bin =0; while(accum<=target && i_bin<n_M_bins){ size_t idx_i=M_hist_index[n_M_bins-i_bin-1]; if(idx_i<i_68_lo) i_68_lo=idx_i; if(idx_i>i_68_hi) i_68_hi=idx_i; accum+=M_hist[i_snap][idx_i]; i_bin++; } M_peak[i_snap] =M_min+((double)i_peak +0.5)*dM; M_68_lo[i_snap]=M_min+((double)i_68_lo+0.5)*dM; M_68_hi[i_snap]=M_min+((double)i_68_hi+0.5)*dM; SID_free(SID_FARG M_hist_index); } else{ M_peak[i_snap] =-1; M_68_lo[i_snap]=-1; M_68_hi[i_snap]=-1; } } // Write results char filename_out[MAX_FILENAME_LENGTH]; FILE *fp_out; sprintf(filename_out,"%s_tracks.txt",catalog_name); fp_out=fopen(filename_out,"w"); for(int i_snap=0;i_snap<n_snaps;i_snap++) fprintf(fp_out,"%le %le %d %le %le %le\n", z_list[i_snap], t_list[i_snap]/S_PER_YEAR, n_i[i_snap], M_peak[i_snap], M_68_lo[i_snap], M_68_hi[i_snap]); fclose(fp_out); // Clean-up for(int i_snap=0;i_snap<n_snaps;i_snap++) SID_free(SID_FARG M_hist[i_snap]); SID_free(SID_FARG M_hist); SID_free(SID_FARG n_i); SID_free(SID_FARG M_peak); SID_free(SID_FARG M_68_lo); SID_free(SID_FARG M_68_hi); SID_free(SID_FARG i_z_track); SID_free(SID_FARG idx_track); SID_free(SID_FARG M_track); SID_free(SID_FARG x_track); SID_free(SID_FARG y_track); SID_free(SID_FARG z_track); SID_free(SID_FARG vx_track); SID_free(SID_FARG vy_track); SID_free(SID_FARG vz_track); SID_free(SID_FARG snap_list); SID_free(SID_FARG z_list); SID_free(SID_FARG t_list); SID_log("Done.",SID_LOG_CLOSE); } // if I_am_Master SID_Barrier(SID.COMM_WORLD); SID_log("Done.",SID_LOG_CLOSE); }
void read_matches(char *filename_in_dir, int i_read_in, int j_read_in, int n_halos_max, int mode, int *n_groups_i, int *n_groups_j, int *n_particles_i_in, int *n_particles_j_in, int *n_sub_group_i_in, int *n_sub_group_j_in, int *match_ids, float *match_score, size_t *match_index, char *match_flag_two_way, int flag_reject_bad_matches){ char group_text_prefix[5]; char filename_in[MAX_FILENAME_LENGTH]; SID_fp fp_in; int k_read; int l_read; int n_search; int n_matches; size_t offset; int flag_continue; int i_read_file; int j_read_file; int n_groups_file; int n_groups_file_1; int n_groups_file_2; int n_groups; int n_groups_i_file; int n_groups_j_file; int *n_sub_group_i; int *n_sub_group_j; int flag_alloc_n_sub_i=FALSE; int flag_alloc_n_sub_j=FALSE; if(i_read_in==j_read_in) SID_trap_error("i_read=j_read in read_matches",ERROR_LOGIC); switch(mode){ case MATCH_SUBGROUPS: sprintf(group_text_prefix,"sub"); break; case MATCH_GROUPS: sprintf(group_text_prefix,""); // We need n_subgroups arrays for removal of bad groups // if they have not been passed to us. if(n_sub_group_i_in==NULL){ flag_alloc_n_sub_i=TRUE; n_sub_group_i =(int *)SID_malloc(sizeof(int)*n_halos_max); } else n_sub_group_i=n_sub_group_i_in; if(n_sub_group_j_in==NULL){ flag_alloc_n_sub_j=TRUE; n_sub_group_j =(int *)SID_malloc(sizeof(int)*n_halos_max); } else n_sub_group_j=n_sub_group_j_in; break; } // Since we need the particle counts for the goodness of match criterion, // create temporary arrays in case we weren't passed an array for them. int *n_particles_i=n_particles_i_in; int *n_particles_j=n_particles_j_in; // 1) We always need n_particles_i int flag_alloc_n_particles_i=FALSE; int flag_alloc_n_particles_j=FALSE; if(n_particles_i==NULL) flag_alloc_n_particles_i=TRUE; if(n_particles_j==NULL) flag_alloc_n_particles_j=TRUE; // 2) We need n_particles_j if doing 2-way checks if(match_flag_two_way!=NULL && n_particles_j==NULL) flag_alloc_n_particles_j=TRUE; // Read the needed info from the header file int i_read; int i_read_start; int i_read_stop; int n_search_total; int n_files; int n_groups_in; int counter=0; char filename_in_name[256]; strcpy(filename_in_name,filename_in_dir); strip_path(filename_in_name); sprintf(filename_in,"%s/%sgroup_matches_header.dat",filename_in_dir,group_text_prefix); SID_fopen(filename_in,"r",&fp_in); SID_fread(&i_read_start, sizeof(int),1,&fp_in); SID_fread(&i_read_stop, sizeof(int),1,&fp_in); SID_fread(&n_search_total,sizeof(int),1,&fp_in); SID_fread(&n_files, sizeof(int),1,&fp_in); for(i_read=i_read_stop;i_read>=i_read_start && counter<2;i_read--){ SID_fread(&i_read_file, sizeof(int),1,&fp_in); if(i_read_file==i_read_in){ SID_fread(n_groups_i,sizeof(int),1,&fp_in); if((*n_groups_i)>0){ // Create a temporary array for n_particles_i if we were not passed one if(flag_alloc_n_particles_i) n_particles_i=(int *)SID_malloc(sizeof(int)*(*n_groups_i)); if(n_particles_i!=NULL) SID_fread_ordered(n_particles_i,sizeof(int),(size_t)(*n_groups_i),&fp_in); else SID_fskip(sizeof(int),(*n_groups_i),&fp_in); if(mode==MATCH_GROUPS){ if(n_sub_group_i!=NULL) SID_fread_ordered(n_sub_group_i,sizeof(int),(size_t)(*n_groups_i),&fp_in); else SID_fskip(sizeof(int),(*n_groups_i),&fp_in); } } counter++; } else if(i_read_file==j_read_in){ SID_fread(n_groups_j,sizeof(int),1,&fp_in); if((*n_groups_j)>0){ if(flag_alloc_n_particles_j) n_particles_j=(int *)SID_malloc(sizeof(int)*(*n_groups_j)); if(n_particles_j!=NULL) SID_fread_ordered(n_particles_j,sizeof(int),(size_t)(*n_groups_j),&fp_in); else SID_fskip(sizeof(int),(*n_groups_j),&fp_in); if(mode==MATCH_GROUPS){ if(n_sub_group_j!=NULL) SID_fread_ordered(n_sub_group_j,sizeof(int),(size_t)(*n_groups_j),&fp_in); else SID_fskip(sizeof(int),(*n_groups_j),&fp_in); } } counter++; } else{ SID_fread(&n_groups_in,sizeof(int),1,&fp_in); if(n_groups_in>0){ SID_fskip(sizeof(int),n_groups_in,&fp_in); if(mode==MATCH_GROUPS) SID_fskip(sizeof(int),n_groups_in,&fp_in); } } } SID_fclose(&fp_in); // Read the matching file char filename_cat1[256]; char filename_cat2[256]; char filename_in_dir_snap[256]; sprintf(filename_cat1,"%03d",i_read_in); sprintf(filename_cat2,"%03d",j_read_in); sprintf(filename_in_dir_snap,"%s/%s",filename_in_dir,filename_cat1); if(filename_in_dir!=NULL) sprintf(filename_in,"%s/%sgroup_matches_%s_%s.dat",filename_in_dir_snap,group_text_prefix,filename_cat1,filename_cat2); else sprintf(filename_in,"%s_%sgroup_matches_%s_%s.dat",filename_in_name, group_text_prefix,filename_cat1,filename_cat2); SID_fopen(filename_in,"r",&fp_in); SID_fread(&i_read_file,sizeof(int),1,&fp_in); SID_fread(&j_read_file,sizeof(int),1,&fp_in); SID_fread(n_groups_i, sizeof(int),1,&fp_in); SID_fread(n_groups_j, sizeof(int),1,&fp_in); // Read matching data SID_fread(match_ids, sizeof(int), (*n_groups_i),&fp_in); SID_fread(match_index,sizeof(size_t),(*n_groups_i),&fp_in); SID_fread(match_score,sizeof(float), (*n_groups_i),&fp_in); SID_fclose(&fp_in); // If one of the catalogs is empty, set to no-match defaults if((*n_groups_i)<=0 || (*n_groups_j)<=0){ for(int i_halo=0;i_halo<(*n_groups_i);i_halo++){ match_ids[i_halo] =-1; match_score[i_halo]= 0.; } if(match_flag_two_way!=NULL){ for(int i_halo=0;i_halo<(*n_groups_i);i_halo++) match_flag_two_way[i_halo]=FALSE; } } else{ // If we are reading groups, nullify all matches // between halos with no substructures. int i_halo; if(mode==MATCH_GROUPS){ size_t *match_index_temp; for(i_halo=0;i_halo<(*n_groups_i);i_halo++){ if(n_sub_group_i[i_halo]<=0){ match_ids[i_halo] =-1; match_score[i_halo]= 0.; } else if(match_ids[i_halo]>=0 && (*n_groups_j)>0){ if(n_sub_group_j[match_ids[i_halo]]<=0){ match_ids[i_halo] =-1; match_score[i_halo]= 0.; } } } merge_sort(match_ids,(size_t)(*n_groups_i),&match_index_temp,SID_INT,SORT_COMPUTE_INDEX,SORT_COMPUTE_NOT_INPLACE); memcpy(match_index,match_index_temp,(*n_groups_i)*sizeof(size_t)); SID_free(SID_FARG match_index_temp); } // Apply a goodness-of-fit criterion and check that the maximum allowed score has not been exceeded for(i_halo=0;i_halo<(*n_groups_i);i_halo++){ if(match_ids[i_halo]>=0){ if(flag_reject_bad_matches && !check_validity_of_match(n_particles_i[i_halo],match_score[i_halo])) match_ids[i_halo]=-1; } } // Since we may have changed some matches with the goodness // of fit criterion, we need to re-perform the sort size_t *match_index_temp=NULL; merge_sort(match_ids,(size_t)(*n_groups_i),&match_index_temp,SID_INT,SORT_COMPUTE_INDEX,SORT_COMPUTE_NOT_INPLACE); memcpy(match_index,match_index_temp,(*n_groups_i)*sizeof(size_t)); SID_free(SID_FARG match_index_temp); // Determine if the matches are two-way if we have been asked to check this if(match_flag_two_way!=NULL && (*n_groups_i)>0){ // We're going to need the particle counts in the target catalog for checking the goodness of return matches. Make sure we have them. if(n_particles_j==NULL) SID_trap_error("Target catalog halo sizes are not defined in read_matches() but are needed for checking two-way match flags.",ERROR_LOGIC); // Flip the file names for reading the return matches sprintf(filename_in_dir_snap,"%s/%s",filename_in_dir,filename_cat2); if(filename_in_dir!=NULL) sprintf(filename_in,"%s/%sgroup_matches_%s_%s.dat",filename_in_dir_snap,group_text_prefix,filename_cat2,filename_cat1); else sprintf(filename_in,"%s_%sgroup_matches_%s_%s.dat",filename_in_name, group_text_prefix,filename_cat2,filename_cat1); // Open two files, one for reading the IDs and one for matching the scores of the matching file int i_read_file_check; int j_read_file_check; int n_groups_i_check; int n_groups_j_check; SID_fp fp_check_ids; SID_fp fp_check_score; SID_fopen(filename_in,"r",&fp_check_ids); SID_fopen(filename_in,"r",&fp_check_score); SID_fread(&j_read_file_check,sizeof(int),1,&fp_check_ids); SID_fread(&i_read_file_check,sizeof(int),1,&fp_check_ids); SID_fread(&n_groups_j_check, sizeof(int),1,&fp_check_ids); SID_fread(&n_groups_i_check, sizeof(int),1,&fp_check_ids); // Check that we have the right files if(n_groups_i_check!=(*n_groups_i)) SID_trap_error("Source halo counts don't match (ie. %d!=%d) in two-way check in read_matches().",ERROR_LOGIC,n_groups_i_check,(*n_groups_i)); if(n_groups_j_check!=(*n_groups_j)) SID_trap_error("Target halo counts don't match (ie. %d!=%d) in two-way check in read_matches().",ERROR_LOGIC,n_groups_j_check,(*n_groups_j)); if(i_read_file_check!=i_read_file) SID_trap_error("Source file numbers don't match (ie. %d!=%d) in two-way check in read_matches().",ERROR_LOGIC,i_read_file_check,i_read_file); if(j_read_file_check!=j_read_file) SID_trap_error("Target file numbers don't match (ie. %d!=%d) in two-way check in read_matches().",ERROR_LOGIC,j_read_file_check,j_read_file); // Skip to the beginning of the relevant block for the score-reading file pointer SID_fskip(sizeof(int), 4, &fp_check_score); // header SID_fskip(sizeof(int), (*n_groups_j),&fp_check_score); // ids SID_fskip(sizeof(size_t),(*n_groups_j),&fp_check_score); // indices // Set everything to being a one-way match unless subsequently changed for(i_halo=0;i_halo<(*n_groups_i);i_halo++) match_flag_two_way[i_halo]=FALSE; // Read matching data in buffered chunks int n_good =0; int n_2way =0; int n_buffer =1024*1024; int n_chunk =0; int n_remaining =(*n_groups_j); int *buffer_ids =(int *)SID_malloc(sizeof(int) *n_buffer); float *buffer_score=(float *)SID_malloc(sizeof(float)*n_buffer); for(int j_halo=0;n_remaining>0;n_remaining-=n_chunk){ n_chunk=MIN(n_remaining,n_buffer); SID_fread(buffer_ids, sizeof(int), n_chunk,&fp_check_ids); SID_fread(buffer_score,sizeof(float),n_chunk,&fp_check_score); for(int k_halo=0;k_halo<n_chunk;k_halo++,j_halo++){ int id_i=buffer_ids[k_halo]; if(id_i>=0){ if(id_i>=(*n_groups_i)) SID_trap_error("Allowed matching index has been exceeded i(ie %d>=%d) while determining two-way match flags.", ERROR_LOGIC,id_i,(*n_groups_i)); // Do this check first to avoid having to check if both needed n_particles_* references are defined int id_j=match_ids[id_i]; if(id_j==j_halo){ if(!flag_reject_bad_matches || check_validity_of_match(n_particles_j[j_halo],buffer_score[k_halo])){ match_flag_two_way[id_i]=TRUE; n_2way++; } n_good++; } } } } //SID_log("n_good=%d n_2way=%d",SID_LOG_COMMENT,n_good,n_2way); SID_fclose(&fp_check_ids); SID_fclose(&fp_check_score); SID_free(SID_FARG buffer_ids); SID_free(SID_FARG buffer_score); } } // If any of these arrays are temporary, free them. if(flag_alloc_n_sub_i) SID_free(SID_FARG n_sub_group_i); if(flag_alloc_n_sub_j) SID_free(SID_FARG n_sub_group_j); if(flag_alloc_n_particles_i) SID_free(SID_FARG n_particles_i); if(flag_alloc_n_particles_j) SID_free(SID_FARG n_particles_j); }
int main(int argc, char *argv[]) { int n_search; int i_halo; char filename_in[SID_MAX_FILENAME_LENGTH]; char group_text_prefix[4]; int n_files; int k_read; int l_read; int * n_particles_i; int * n_particles_j; int j_read; int mode; int j_halo; int i_read; int i_read_start; int i_read_stop; SID_fp fp_in; SID_Init(&argc, &argv, NULL); // Fetch user inputs char filename_SSimPL_root[SID_MAX_FILENAME_LENGTH]; strcpy(filename_SSimPL_root, argv[1]); SID_log("Checking the integrity of the match files for {%s}...", SID_LOG_OPEN | SID_LOG_TIMER, filename_SSimPL_root); int *n_groups = NULL; int *n_subgroups = NULL; for(int i_type = 0; i_type < 2; i_type++) { // Convert filename_root to filename switch(i_type) { case 0: mode = MATCH_SUBGROUPS; sprintf(group_text_prefix, "sub"); break; case 1: mode = MATCH_GROUPS; sprintf(group_text_prefix, ""); break; } SID_log("Processing %sgroups...", SID_LOG_OPEN | SID_LOG_TIMER, group_text_prefix); // Set the standard SSiMPL match file path char filename_root_in[SID_MAX_FILENAME_LENGTH]; sprintf(filename_root_in, "%s/trees/matches/", filename_SSimPL_root); // Read halo sizes from header file SID_log("Processing header file...", SID_LOG_OPEN | SID_LOG_TIMER); 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_fread(&i_read_stop, sizeof(int), 1, &fp_in); SID_fread(&n_search, sizeof(int), 1, &fp_in); SID_fread(&n_files, sizeof(int), 1, &fp_in); int *n_halos = NULL; switch(mode) { case MATCH_SUBGROUPS: n_subgroups = (int *)SID_malloc(sizeof(int) * n_files); n_halos = n_subgroups; break; case MATCH_GROUPS: n_groups = (int *)SID_malloc(sizeof(int) * n_files); n_halos = n_groups; break; } if(mode == MATCH_GROUPS) SID_log("Halo counts (snap/No. groups/No. subgroups):", SID_LOG_OPEN); for(k_read = 0; k_read < n_files; k_read++) { SID_fread(&l_read, sizeof(int), 1, &fp_in); SID_fread(&(n_halos[k_read]), sizeof(int), 1, &fp_in); SID_fskip(sizeof(int), n_halos[k_read], &fp_in); if(mode == MATCH_GROUPS) { int *n_subgroups_group = (int *)SID_malloc(sizeof(int) * n_halos[k_read]); SID_fread(n_subgroups_group, sizeof(int), n_halos[k_read], &fp_in); int n_subgroups_test = 0; for(int i_test = 0; i_test < n_halos[k_read]; i_test++) n_subgroups_test += n_subgroups_group[i_test]; if(n_subgroups[k_read] != n_subgroups_test) SID_log("Error in %s header: l_read=%3d k_read=%3d n_subgroups: %d!=%d\n", SID_LOG_COMMENT, l_read, k_read, n_subgroups[k_read], n_subgroups_test); SID_free(SID_FARG n_subgroups_group); } if(mode == MATCH_GROUPS) SID_log("%03d %d %d", SID_LOG_COMMENT, k_read, n_groups[k_read], n_subgroups[k_read]); } if(mode == MATCH_GROUPS) SID_log("", SID_LOG_CLOSE | SID_LOG_NOPRINT); SID_fclose(&fp_in); SID_log("Done.", SID_LOG_CLOSE); SID_log("Processing match files...", SID_LOG_OPEN | SID_LOG_TIMER); for(int i_read = i_read_start; i_read < i_read_stop; i_read++) { for(int j_read = GBP_MAX(0, i_read - n_search); j_read < GBP_MIN(i_read_stop, i_read + n_search); j_read++) { if(i_read != j_read) { sprintf(filename_in, "%s/%03d/%sgroup_matches_%03d_%03d.dat", filename_root_in, i_read, group_text_prefix, i_read, j_read); SID_log("Processing {%s}...", SID_LOG_OPEN, filename_in); // Read header information int i_read_in; int j_read_in; int n_groups_i; int n_groups_j; SID_fopen(filename_in, "r", &fp_in); SID_fread(&i_read_in, sizeof(int), 1, &fp_in); SID_fread(&j_read_in, sizeof(int), 1, &fp_in); SID_fread(&n_groups_i, sizeof(int), 1, &fp_in); SID_fread(&n_groups_j, sizeof(int), 1, &fp_in); if(i_read_in != i_read || j_read_in != j_read || n_groups_i != n_halos[n_files - i_read_in - 1] || n_groups_j != n_halos[n_files - j_read_in - 1]) SID_log("Error in matching file: i_read=%3d j_read=%3d n_i_in=%d n_i=%d n_j_in=%d n_j=%d\n", SID_LOG_COMMENT, i_read, j_read, n_groups_i, n_halos[n_files - i_read_in - 1], n_groups_j, n_halos[n_files - j_read_in - 1]); // Read matches int match; for(k_read = 0; k_read < n_groups_i; k_read++) SID_fread(&match, sizeof(int), 1, &fp_in); // Read indices size_t indices; for(k_read = 0; k_read < n_groups_i; k_read++) SID_fread(&indices, sizeof(size_t), 1, &fp_in); // Read scores float score; for(k_read = 0; k_read < n_groups_i; k_read++) SID_fread(&score, sizeof(float), 1, &fp_in); // Close file SID_fclose(&fp_in); SID_log("Done.", SID_LOG_CLOSE); } } } SID_log("Done.", SID_LOG_CLOSE); SID_log("Done.", SID_LOG_CLOSE); } SID_free(SID_FARG n_groups); SID_free(SID_FARG n_subgroups); SID_log("Done.", SID_LOG_CLOSE); SID_Finalize(); }
int read_matches_header(char *filename_root_in, int i_read_start, int i_read_stop, int i_read_step, int * n_files_return, int **n_subgroups_return, int **n_groups_return, int * n_subgroups_max, int * n_groups_max, int * n_halos_max) { char filename_out[256]; char filename_out_dir[256]; char filename_out_name[256]; FILE * fp_test; FILE * fp_out; SID_fp fp_in; int i_read, k_read, l_read; int i_read_start_file; int i_read_stop_file; int i_read_step_file; int k_match; int n_k_match; char group_text_prefix[5]; int n_matches; int j_read; char filename_cat1[256]; char filename_cat2[256]; char filename_cat1_order[256]; char filename_cat2_order[256]; char filename_out_dir_snap[256]; int n_groups_1; int n_groups_1_local; int n_groups_2; int n_groups_2_local; int i_group; int buffered_count; int buffered_count_local; int j_group; int index_test; int i_rank; int * n_particles; int * n_sub_group; int * match_id = NULL; float * match_score = NULL; char cat_name_1[20]; char cat_name_2[20]; size_t * match_rank = NULL; size_t * match_index = NULL; size_t offset; plist_info plist1; plist_info plist2; void * buffer; int * buffer_int; size_t * buffer_size_t; float * buffer_float; int n_buffer_max = 1000; int n_buffer; int i_buffer; int j_buffer; int flag_sucessful_completion = GBP_TRUE; SID_log("Reading header information...", SID_LOG_OPEN); // Count the number of snapshots we are going to use and // initialize the arrays that are to be returned for(i_read = i_read_stop, (*n_files_return) = 0; i_read >= i_read_start; i_read -= i_read_step) (*n_files_return)++; (*n_subgroups_return) = (int *)SID_malloc(sizeof(int) * (*n_files_return)); (*n_groups_return) = (int *)SID_malloc(sizeof(int) * (*n_files_return)); if(SID.I_am_Master) { FILE *fp_read_header; // Loop for subgroups and then groups for(k_match = 0; k_match < 2; k_match++) { switch(k_match) { case 0: sprintf(group_text_prefix, "sub"); break; case 1: sprintf(group_text_prefix, ""); break; } // Open file and read header int i_read_start_in; int i_read_stop_in; int n_search_total_in; int n_files_in; int i_read_in; sprintf(filename_out, "%s/%sgroup_matches_header.dat", filename_root_in, group_text_prefix); if((fp_read_header = fopen(filename_out, "r")) == NULL) SID_exit_error("Could not open file {%s} when reading header information.", SID_ERROR_IO_OPEN, filename_out); SID_fread_verify(&i_read_start_in, sizeof(int), 1, fp_read_header); SID_fread_verify(&i_read_stop_in, sizeof(int), 1, fp_read_header); SID_fread_verify(&n_search_total_in, sizeof(int), 1, fp_read_header); SID_fread_verify(&n_files_in, sizeof(int), 1, fp_read_header); i_read_in = i_read_stop_in + 1; // Loop for each snapshot we want to keep int i_read_next; for(j_read = 0, i_read_next = i_read_stop; j_read < (*n_files_return); j_read++, i_read_next -= i_read_step) { // Read-forward to the desired snapshot int flag_continue = GBP_TRUE; while(flag_continue && i_read_in > i_read_start_in) { SID_fread_verify(&i_read_in, sizeof(int), 1, fp_read_header); SID_fread_verify(&n_groups_1, sizeof(int), 1, fp_read_header); fseek(fp_read_header, n_groups_1 * sizeof(int), SEEK_CUR); // Skip halo sizes if(k_match == 1) fseek(fp_read_header, n_groups_1 * sizeof(int), SEEK_CUR); // Skip n_sub_per_group if(i_read_in == i_read_next) { switch(k_match) { case 0: (*n_subgroups_return)[j_read] = n_groups_1; break; case 1: (*n_groups_return)[j_read] = n_groups_1; break; } flag_continue = GBP_FALSE; } } } fclose(fp_read_header); if(j_read != (*n_files_return)) SID_exit_error("Was not able to read the appriate number of group/subgroup sizes (i.e. %d!=%d)", SID_ERROR_LOGIC, j_read, (*n_files_return)); } } SID_Bcast((*n_subgroups_return), (*n_files_return), SID_INT, SID_MASTER_RANK, SID_COMM_WORLD); SID_Bcast((*n_groups_return), (*n_files_return), SID_INT, SID_MASTER_RANK, SID_COMM_WORLD); // Compute some maxs (useful for array allocation) calc_max((*n_subgroups_return), n_subgroups_max, (*n_files_return), SID_INT, CALC_MODE_DEFAULT); calc_max((*n_groups_return), n_groups_max, (*n_files_return), SID_INT, CALC_MODE_DEFAULT); (*n_halos_max) = GBP_MAX((*n_subgroups_max), (*n_groups_max)); SID_log("Done.", SID_LOG_CLOSE); return (flag_sucessful_completion); }
int main(int argc, char *argv[]){ char filename_tree_in[256]; int select_tree; int n_trees; int n_halos_total; int *n_halos; int i_tree; FILE *fp; halo_properties_SAGE_info *halos; halo_properties_SAGE_info halo; int *snap_num; size_t *snap_num_index; int i_snap,i_halo,j_halo,k_halo; int n_halos_snap; int *group_halo_first; int group_halo_last; size_t *group_halo_first_index; int *snap_index; int descendant_min,descendant_max; int progenitor_first_min,progenitor_first_max; int progenitor_next_min,progenitor_next_max; int group_halo_first_min,group_halo_first_max; int group_halo_next_min,group_halo_next_max; int snap_num_min,snap_num_max; int halo_index_min,halo_index_max; int n_gal=0; int max_snap=0; SID_init(&argc,&argv,NULL,NULL); // Fetch user inputs strcpy(filename_tree_in,argv[1]); select_tree=atoi(argv[2]); SID_log("Displaying tree %d from {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,select_tree,filename_tree_in); fp=fopen(filename_tree_in,"r"); fread_verify(&n_trees, sizeof(int),1,fp); fread_verify(&n_halos_total,sizeof(int),1,fp); SID_log("(%d trees and %d halos)...",SID_LOG_CONTINUE,n_trees,n_halos_total); n_halos=(int *)SID_malloc(sizeof(int)*n_trees); fread_verify(n_halos,sizeof(int),n_trees,fp); for(i_tree=0;i_tree<select_tree;i_tree++){ for(i_halo=0;i_halo<n_halos[i_tree];i_halo++){ fread_verify(&halo,sizeof(halo_properties_SAGE_info),1,fp); max_snap=MAX(max_snap,halo.snap_num); } } halos =(halo_properties_SAGE_info *)SID_malloc(sizeof(halo_properties_SAGE_info)*n_halos[i_tree]); snap_num =(int *)SID_malloc(sizeof(int)*n_halos[i_tree]); snap_index =(int *)SID_malloc(sizeof(int)*n_halos[i_tree]); group_halo_first =(int *)SID_malloc(sizeof(int)*n_halos[i_tree]); fread_verify(halos,sizeof(halo_properties_SAGE_info),n_halos[i_tree],fp); descendant_min =10000; descendant_max = 0; progenitor_first_min=10000; progenitor_first_max= 0; progenitor_next_min =10000; progenitor_next_max = 0; group_halo_first_min=10000; group_halo_first_max= 0; group_halo_next_min =10000; group_halo_next_max = 0; snap_num_min =10000; snap_num_max = 0; halo_index_min =10000; halo_index_max = 0; for(i_halo=0;i_halo<n_halos[i_tree];i_halo++){ snap_num[i_halo] =halos[i_halo].snap_num; if(halos[i_halo].descendant>=0) descendant_min =MIN(descendant_min,halos[i_halo].descendant); if(halos[i_halo].progenitor_first>=0) progenitor_first_min=MIN(progenitor_first_min,halos[i_halo].progenitor_first); if(halos[i_halo].progenitor_next>=0) progenitor_next_min =MIN(progenitor_next_min,halos[i_halo].progenitor_next); if(halos[i_halo].group_halo_first>=0) group_halo_first_min=MIN(group_halo_first_min,halos[i_halo].group_halo_first); if(halos[i_halo].group_halo_next>=0) group_halo_next_min =MIN(group_halo_next_min,halos[i_halo].group_halo_next); if(halo.snap_num>=0) snap_num_min =MIN(snap_num_min,halos[i_halo].snap_num); if(halos[i_halo].halo_index>=0) halo_index_min =MIN(halo_index_min,halos[i_halo].halo_index); descendant_max =MAX(descendant_max,halos[i_halo].descendant); progenitor_first_max=MAX(progenitor_first_max,halos[i_halo].progenitor_first); progenitor_next_max =MAX(progenitor_next_max,halos[i_halo].progenitor_next); group_halo_first_max=MAX(group_halo_first_max,halos[i_halo].group_halo_first); group_halo_next_max =MAX(group_halo_next_max,halos[i_halo].group_halo_next); snap_num_max =MAX(snap_num_max,halos[i_halo].snap_num); halo_index_max =MAX(halo_index_max,halos[i_halo].halo_index); max_snap=MAX(max_snap,halos[i_halo].snap_num); } i_tree++; for(;i_tree<n_trees;i_tree++){ for(i_halo=0;i_halo<n_halos[i_tree];i_halo++){ fread_verify(&halo,sizeof(halo_properties_SAGE_info),1,fp); max_snap=MAX(max_snap,halo.snap_num); } } rewind(fp); fread_verify(&n_trees, sizeof(int),1,fp); fread_verify(&n_halos_total,sizeof(int),1,fp); for(i_tree=0,n_gal=0;i_tree<n_trees;i_tree++){ for(i_halo=0;i_halo<n_halos[i_tree];i_halo++){ fread_verify(&halo,sizeof(halo_properties_SAGE_info),1,fp); if(halo.snap_num==max_snap) n_gal++; } } SID_log("n_trees =%d", SID_LOG_COMMENT,n_trees); SID_log("n_halos[snap=%3d]=%d", SID_LOG_COMMENT,n_gal); SID_log("n_halos_total =%d", SID_LOG_COMMENT,n_halos_total); SID_log("Descendants =%d->%d",SID_LOG_COMMENT,descendant_min, descendant_max); SID_log("Progenitor_first =%d->%d",SID_LOG_COMMENT,progenitor_first_min,progenitor_first_max); SID_log("Progenitor_next =%d->%d",SID_LOG_COMMENT,progenitor_next_min, progenitor_next_max); SID_log("Group_halo_first =%d->%d",SID_LOG_COMMENT,group_halo_first_min,group_halo_first_max); SID_log("Group_halo_next =%d->%d",SID_LOG_COMMENT,group_halo_next_min, group_halo_next_max); SID_log("Snap_num =%d->%d",SID_LOG_COMMENT,snap_num_min, snap_num_max); SID_log("Halo_index =%d->%d",SID_LOG_COMMENT,halo_index_min, halo_index_max); merge_sort((void *)snap_num,(size_t)n_halos[i_tree],&snap_num_index,SID_INT,SORT_COMPUTE_INDEX,FALSE); for(i_snap=snap_num_max,i_halo=n_halos[i_tree]-1;i_snap>=snap_num_min && i_halo>=0;i_snap--){ n_halos_snap=0; while(snap_num[snap_num_index[i_halo]]==i_snap && i_halo>0){ n_halos_snap++; i_halo--; } if(snap_num[snap_num_index[i_halo]]==i_snap){ n_halos_snap++; i_halo--; } for(j_halo=0;j_halo<n_halos_snap;j_halo++){ group_halo_first[j_halo]=halos[snap_num_index[i_halo+j_halo+1]].group_halo_first; snap_index[j_halo] =snap_num_index[i_halo+j_halo+1]; } merge_sort((void *)group_halo_first,(size_t)n_halos_snap,&group_halo_first_index,SID_INT,SORT_COMPUTE_INDEX,FALSE); group_halo_last=-99; if(n_halos_snap>0) printf("Snap #%3d: ",i_snap); for(j_halo=0;j_halo<n_halos_snap;j_halo++){ k_halo=snap_index[group_halo_first_index[j_halo]]; if(group_halo_last!=halos[k_halo].group_halo_first){ if(j_halo!=0) printf(") "); printf("("); } else printf(" "); // Generate output /* printf("I:%5d->%5d/S:%5d/PF:%5d/PN:%5d/G:%5d->%5d", k_halo, halos[k_halo].descendant, halos[k_halo].n_particles, halos[k_halo].progenitor_first, halos[k_halo].progenitor_next, halos[k_halo].group_halo_first, halos[k_halo].group_halo_next); */ /* printf("I%05d.D%05d.S%05d.F%05d.N%05d.f%05d.n%05d", k_halo, halos[k_halo].descendant, halos[k_halo].n_particles, halos[k_halo].progenitor_first, halos[k_halo].progenitor_next, halos[k_halo].group_halo_first, halos[k_halo].group_halo_next); */ /* printf("%05d", halos[k_halo].n_particles); */ /* printf("%05d/%05d/%05d", k_halo,halos[k_halo].descendant, halos[k_halo].n_particles); */ printf("%05d/%05d/%05d/%05d", k_halo, halos[k_halo].descendant, halos[k_halo].group_halo_first, halos[k_halo].group_halo_next); group_halo_last=halos[k_halo].group_halo_first; } if(n_halos_snap>0) printf(")\n"); SID_free((void **)&group_halo_first_index); } SID_free((void **)&snap_num_index); SID_free((void **)&snap_num); SID_free((void **)&snap_index); SID_free((void **)&group_halo_first); SID_free((void **)&n_halos); SID_free((void **)&halos); fclose(fp); SID_log("Done.",SID_LOG_CLOSE); SID_exit(0); }
int main(int argc, char *argv[]){ 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); }
void SID_cat_files(const char *filename_out, int mode, int n_files, ...){ int i_file; char *filename_in; va_list vargs; FILE *fp_in; FILE *fp_out; int r_val; int flag_clean; struct stat file_stats; size_t n_bytes; size_t n_bytes_buffer; void *buffer; va_start(vargs,n_files); SID_log("Concatinating %d files to output {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,n_files,filename_out); // Interpret mode if(check_mode_for_flag(mode,SID_CAT_CLEAN)) flag_clean=TRUE; else flag_clean=FALSE; // Open output file fp_out=fopen(filename_out,"w"); if(fp_out==NULL) SID_trap_error("Could not open file {%s}!",ERROR_IO_OPEN,filename_out); buffer=SID_malloc(IO_BUFFER_SIZE); // Loop over the files to be concatinated... for(i_file=0;i_file<n_files;i_file++){ // Open next file and get file size filename_in=(char *)va_arg(vargs,char *); r_val =stat(filename_in,&file_stats); if(r_val!=0) SID_trap_error("Could not open file {%s}!",ERROR_IO_OPEN,filename_in); else SID_log("Processing {%s}...",SID_LOG_OPEN,filename_in); n_bytes=file_stats.st_size; fp_in =fopen(filename_in,"r"); // Copy this input file to the output file in chunks ... n_bytes_buffer=MIN(n_bytes,IO_BUFFER_SIZE); while(n_bytes_buffer>0){ // Read r_val=fread(buffer, 1, n_bytes_buffer, fp_in); // Write r_val=fwrite(buffer, 1, n_bytes_buffer, fp_out); // Adjust buffer size n_bytes-=n_bytes_buffer; n_bytes_buffer=MIN(n_bytes,IO_BUFFER_SIZE); } // Close input file and remove it if asked to fclose(fp_in); if(flag_clean) remove(filename_in); SID_log("Done.",SID_LOG_CLOSE); } // Clean-up fclose(fp_out); SID_free(SID_FARG buffer); SID_log("Done.",SID_LOG_CLOSE); va_end(vargs); }
int main(int argc, char *argv[]){ char filename_tree_in[256]; int n_trees; int n_halos_total; int *n_halos; int i_tree; FILE *fp; halo_properties_SAGE_info *halos; halo_properties_SAGE_info halo; int *snap_num; size_t *snap_num_index; int i_snap,i_halo,j_halo,k_halo; int n_halos_snap; int *group_halo_first; int group_halo_last; size_t *group_halo_first_index; int *snap_index; int descendant_min,descendant_max; int progenitor_first_min,progenitor_first_max; int progenitor_next_min,progenitor_next_max; int group_halo_first_min,group_halo_first_max; int group_halo_next_min,group_halo_next_max; int snap_num_min,snap_num_max; int halo_index_min,halo_index_max; int n_gal=0; int max_snap=0; int n_halos_max; int n_subtrees; int halo_search; int flag_search; SID_init(&argc,&argv,NULL,NULL); // Fetch user inputs strcpy(filename_tree_in,argv[1]); halo_search=atoi(argv[2]); SID_log("Finding halo #%d's tree in {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,halo_search,filename_tree_in); fp=fopen(filename_tree_in,"r"); fread_verify(&n_trees, sizeof(int),1,fp); fread_verify(&n_halos_total,sizeof(int),1,fp); SID_log("%d trees and %d halos",SID_LOG_COMMENT,n_trees,n_halos_total); n_halos=(int *)SID_malloc(sizeof(int)*n_trees); fread_verify(n_halos,sizeof(int),n_trees,fp); calc_max(n_halos,&n_halos_max,n_trees,SID_INT,CALC_MODE_DEFAULT); halos =(halo_properties_SAGE_info *)SID_malloc(sizeof(halo_properties_SAGE_info)*n_halos_max); for(i_tree=0,flag_search=TRUE;i_tree<n_trees && flag_search;i_tree++){ fread_verify(halos,sizeof(halo_properties_SAGE_info),n_halos[i_tree],fp); for(i_halo=0,n_subtrees=0;i_halo<n_halos[i_tree];i_halo++){ if(halos[i_halo].halo_id==halo_search){ flag_search=FALSE; SID_log("Found it in tree #%d",SID_LOG_COMMENT,i_tree); } } } if(flag_search) SID_log("COULD NOT FIND HALO #%d IN THIS FILE!",SID_LOG_COMMENT,halo_search); // Clean-up fclose(fp); SID_free((void **)&halos); SID_log("Done.",SID_LOG_CLOSE); SID_exit(0); }