int main(int argc, char *argv[]) { SID_Init(&argc, &argv, NULL); // Parse arguments and initialize double z; if(argc < 2 || argc > 3) { fprintf(stderr, "\n Syntax: %s z [gbpCosmo_file.txt]\n", argv[0]); fprintf(stderr, " ------\n\n"); return (SID_ERROR_SYNTAX); } else z = (double)atof(argv[1]); SID_log("Computing cosmology information for z=%.2lf...", SID_LOG_OPEN, z); // Initialize cosmology ADaPS *cosmo = NULL; if(argc == 2) init_cosmo_default(&cosmo); else if(argc == 3) read_gbpCosmo_file(&cosmo, argv[2]); // Output results double h_Hubble = ((double *)ADaPS_fetch(cosmo, "h_Hubble"))[0]; SID_log("R_NL(z) = %10.3lf Mpc", SID_LOG_COMMENT, R_NL_z(z, &cosmo) / M_PER_MPC); SID_log("rho_crit = %13.6le Msol/(Mpc^3)", SID_LOG_COMMENT, rho_crit_z(z, cosmo) * (M_PER_MPC / M_SOL) * M_PER_MPC * M_PER_MPC); SID_log("D_angular = %10.3lf Mpc", SID_LOG_COMMENT, D_angular(z, cosmo) / M_PER_MPC); SID_log("D_luminosity = %10.3lf Mpc", SID_LOG_COMMENT, D_luminosity(z, cosmo) / M_PER_MPC); SID_log("D_comoving = %10.3lf Mpc", SID_LOG_COMMENT, D_comove(z, cosmo) / M_PER_MPC); SID_log("D_horizon = %10.3lf Mpc", SID_LOG_COMMENT, C_VACUUM * deltat_a(&cosmo, 0., a_of_z(z)) / M_PER_MPC); SID_log("D_V = %10.3lf Mpc", SID_LOG_COMMENT, pow((1 + z) * D_angular(z, cosmo) * (1 + z) * D_angular(z, cosmo) * z * C_VACUUM / H_convert(H_z(z, cosmo)), ONE_THIRD) / M_PER_MPC); SID_log("H(z) = %10.3lf km/s/Mpc", SID_LOG_COMMENT, H_z(z, cosmo)); SID_log("t_age(z) = %10.3le years", SID_LOG_COMMENT, t_age_z(z, &cosmo) / S_PER_YEAR); SID_log("t_Hubble(z) = %10.3le years", SID_LOG_COMMENT, t_Hubble_z(z, cosmo) / S_PER_YEAR); SID_log("t_dyn(z) = %10.3le years", SID_LOG_COMMENT, t_dyn_z(z, cosmo) / S_PER_YEAR); SID_log("n_dyn(<z) = %10.3le", SID_LOG_COMMENT, n_dyn_ztoz(0., z, cosmo)); SID_log("Done.", SID_LOG_CLOSE); // Clean-up free_cosmo(&cosmo); SID_Finalize(); }
void free_pspec(pspec_info *pspec){ SID_log("Freeing power spectrum...",SID_LOG_OPEN); free_cosmo(&(pspec->cosmo)); free_field(&(pspec->FFT)); SID_free(SID_FARG (pspec->k_1D)); SID_free(SID_FARG (pspec->n_modes_1D)); SID_free(SID_FARG (pspec->n_modes_2D)); int i_run; for(i_run=0;i_run<4;i_run++){ SID_free(SID_FARG (pspec->P_k_1D[i_run])); SID_free(SID_FARG (pspec->dP_k_1D[i_run])); SID_free(SID_FARG (pspec->P_k_2D[i_run])); SID_free(SID_FARG (pspec->dP_k_2D[i_run])); } SID_free(SID_FARG pspec->P_k_1D); SID_free(SID_FARG pspec->dP_k_1D); SID_free(SID_FARG pspec->P_k_2D); SID_free(SID_FARG pspec->dP_k_2D); SID_log("Done.",SID_LOG_CLOSE); }
void free_trees(tree_info **trees){ SID_log("Freeing trees...",SID_LOG_OPEN); // Free reference trees if((*trees)->trees_reference!=NULL) free_trees(&((*trees)->trees_reference)); // Free look-up arrays free_trees_lookup((*trees)); // Free ADaPS structure ADaPS_free(SID_FARG (*trees)->data); // Free cosmology free_cosmo(&((*trees)->cosmo)); // Free nodes int i_snap; for(i_snap=0;i_snap<(*trees)->n_snaps;i_snap++){ tree_node_info *current; tree_node_info *next; if((*trees)->first_neighbour_groups!=NULL){ next=(*trees)->first_neighbour_groups[i_snap]; while(next!=NULL){ current=next; next =current->next_neighbour; SID_free(SID_FARG current); } } if((*trees)->first_neighbour_subgroups!=NULL){ next=(*trees)->first_neighbour_subgroups[i_snap]; while(next!=NULL){ current=next; next =current->next_neighbour; SID_free(SID_FARG current); } } } // Free match scores for(int i_type=0;i_type<2;i_type++){ float **match_scores; if(i_type==0) match_scores=(*trees)->group_match_scores; else match_scores=(*trees)->subgroup_match_scores; if(match_scores!=NULL){ for(i_snap=0;i_snap<(*trees)->n_snaps;i_snap++) SID_free(SID_FARG match_scores[i_snap]); SID_free(SID_FARG match_scores); } } // Free the various other arrays SID_free(SID_FARG (*trees)->snap_list); SID_free(SID_FARG (*trees)->a_list); SID_free(SID_FARG (*trees)->z_list); SID_free(SID_FARG (*trees)->t_list); SID_free(SID_FARG (*trees)->n_groups_catalog); SID_free(SID_FARG (*trees)->n_subgroups_catalog); SID_free(SID_FARG (*trees)->n_groups_snap_local); SID_free(SID_FARG (*trees)->n_subgroups_snap_local); SID_free(SID_FARG (*trees)->n_groups_forest_local); SID_free(SID_FARG (*trees)->n_subgroups_forest_local); SID_free(SID_FARG (*trees)->first_neighbour_groups); SID_free(SID_FARG (*trees)->first_neighbour_subgroups); SID_free(SID_FARG (*trees)->last_neighbour_groups); SID_free(SID_FARG (*trees)->last_neighbour_subgroups); SID_free(SID_FARG (*trees)->first_in_forest_groups); SID_free(SID_FARG (*trees)->first_in_forest_subgroups); SID_free(SID_FARG (*trees)->last_in_forest_groups); SID_free(SID_FARG (*trees)->last_in_forest_subgroups); SID_free(SID_FARG (*trees)->tree2forest_mapping_group); SID_free(SID_FARG (*trees)->tree2forest_mapping_subgroup); // Free the main structure SID_free(SID_FARG (*trees)); SID_log("Done.",SID_LOG_CLOSE); }
int main(int argc, char *argv[]){ SID_init(&argc,&argv,NULL,NULL); char filename_cosmology[MAX_FILENAME_LENGTH]; char paramterization[MAX_FILENAME_LENGTH]; double log_M_min =atof(argv[1]); double log_M_max =atof(argv[2]); int n_M_bins =atoi(argv[3]); double redshift =atof(argv[4]); strcpy(filename_cosmology,argv[5]); strcpy(paramterization, argv[6]); SID_log("Constructing mass function between log(M)=%5.3lf->%5.3lf at z=%5.3lf...",SID_LOG_OPEN,log_M_min,log_M_max,redshift); // Initialize cosmology cosmo_info *cosmo=NULL; read_gbpCosmo_file(&cosmo,filename_cosmology); // Decide which parameterization we are going to use int select_flag; char mfn_text[32]; if(!strcmp(paramterization,"JENKINS")){ sprintf(mfn_text,"Jenkins"); select_flag=MF_JENKINS; } else if(!strcmp(paramterization,"PS")){ sprintf(mfn_text,"Press & Schechter"); select_flag=MF_PS; } else if(!strcmp(paramterization,"ST")){ sprintf(mfn_text,"Sheth & Tormen"); select_flag=MF_ST; } else SID_trap_error("Invalid parameterization selected {%s}. Should be {JENKINS,PS or ST}.",ERROR_SYNTAX,paramterization); // Create output filename char filename_out[MAX_FILENAME_LENGTH]; char redshift_text[64]; char *cosmology_name=(char *)ADaPS_fetch(cosmo,"name"); float_to_text(redshift,3,redshift_text); sprintf(filename_out,"mass_function_z%s_%s_%s.txt",redshift_text,cosmology_name,paramterization); // Open file and write header FILE *fp_out=NULL; fp_out=fopen(filename_out,"w"); int i_column=1; fprintf(fp_out,"# Mass function (%s) for %s cosmology at z=%lf\n",mfn_text,filename_cosmology,redshift); fprintf(fp_out,"# \n"); fprintf(fp_out,"# Column (%02d): log M [h^-1 M_sol]\n", i_column++); fprintf(fp_out,"# (%02d): Mass function [(h^{-1} Mpc]^{-3} per dlogM]\n", i_column++); fprintf(fp_out,"# (%02d): Cumulative Mass function(>M) [(h^{-1} Mpc]^{-3}]\n",i_column++); // Create the mass function SID_log("Writing results to {%s}...",SID_LOG_OPEN|SID_LOG_TIMER,filename_out); pcounter_info pcounter; SID_init_pcounter(&pcounter,n_M_bins,10); double h_Hubble =((double *)ADaPS_fetch(cosmo,"h_Hubble"))[0]; double mass_factor=M_SOL/h_Hubble; double MFct_factor=pow(M_PER_MPC,3.0); for(int i_bin=0;i_bin<n_M_bins;i_bin++){ double log_M; if(i_bin==0) log_M=log_M_min; else if(i_bin==(n_M_bins-1)) log_M=log_M_max; else log_M=log_M_min+(((double)(i_bin))/((double)(n_M_bins-1)))*(log_M_max-log_M_min); fprintf(fp_out,"%le %le %le\n",log_M, MFct_factor*mass_function (mass_factor*take_alog10(log_M),redshift,&cosmo,select_flag), MFct_factor*mass_function_cumulative(mass_factor*take_alog10(log_M),redshift,&cosmo,select_flag)); SID_check_pcounter(&pcounter,i_bin); } fclose(fp_out); SID_log("Done.",SID_LOG_CLOSE); // Clean-up free_cosmo(&cosmo); SID_log("Done.",SID_LOG_CLOSE); SID_exit(ERROR_NONE); }
int main(int argc, char *argv[]){ SID_init(&argc,&argv,NULL,NULL); // Parse arguments and initialize double z; if(argc<2 || argc>3){ fprintf(stderr,"\n Syntax: %s z [gbpCosmo_file.txt]\n",argv[0]); fprintf(stderr," ------\n\n"); return(ERROR_SYNTAX); } else z=(double)atof(argv[1]); SID_log("Computing clustering information for z=%.2lf...",SID_LOG_OPEN,z); // Initialize cosmology cosmo_info *cosmo=NULL; if(argc==2) init_cosmo_default(&cosmo); else if(argc==3) read_gbpCosmo_file(&cosmo,argv[2]); // Initialize int mode =PSPEC_LINEAR_TF; int component=PSPEC_ALL_MATTER; init_sigma_M(&cosmo,z,mode,component); int n_k =((int *)ADaPS_fetch(cosmo,"n_k"))[0]; double *lk_P = (double *)ADaPS_fetch(cosmo,"lk_P"); double h_Hubble=((double *)ADaPS_fetch(cosmo,"h_Hubble"))[0]; SID_log("Done.",SID_LOG_CLOSE); // Generate file SID_log("Writing table to stdout...",SID_LOG_OPEN); double delta_c =1.686; double m_per_mpc_h=M_PER_MPC/h_Hubble; printf("# Column (01): k [h Mpc^-1]\n"); printf("# (02): R [h^-1 Mpc] \n"); printf("# (03): M [h^-1 M_sol]\n"); printf("# (04): V_max [km/s] \n"); printf("# (05): P_k [(h^-1 Mpc)^3]\n"); printf("# (06): sigma\n"); printf("# (07): nu (peak height)\n"); printf("# (08): b_BPR\n"); printf("# (09): b_TRK\n"); printf("# (10): z-space boost Kaiser '87 (applied to b_TRK)\n"); printf("# (11): b_TRK total (w/ Kaiser boost)\n"); printf("# (12): b_halo_Poole \n"); printf("# (13): z-space boost Poole \n"); printf("# (14): b_total_Poole \n"); printf("# (15): b_halo_Poole (substructure)\n"); printf("# (16): z-space boost Poole (substructure)\n"); printf("# (17): b_total_Poole (substructure)\n"); for(int i_k=0;i_k<n_k;i_k++){ double k_P =take_alog10(lk_P[i_k]); double R_P =R_of_k(k_P); double M_R =M_of_k(k_P,z,cosmo); double P_k =power_spectrum(k_P,z,&cosmo,mode,component); double sigma=sqrt(power_spectrum_variance(k_P,z,&cosmo,mode,component)); double V_max=V_max_NFW(M_R,z,NFW_MODE_DEFAULT,&cosmo); double nu =delta_c/sigma; double bias =1.; if(M_R<1e16*M_SOL){ printf("%10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le %10.5le\n", k_P*m_per_mpc_h, R_P/m_per_mpc_h, M_R/(M_SOL/h_Hubble), V_max*1e-3, P_k/pow(m_per_mpc_h,3.), sigma, nu, bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_BPR), bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_TRK), bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_TRK|BIAS_MODEL_KAISER_BOOST), bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_TRK|BIAS_MODEL_KAISER), bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_POOLE_HALO), bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_POOLE_ZSPACE), bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_POOLE_TOTAL), bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_POOLE_SUBSTRUCTURE|BIAS_MODEL_POOLE_HALO), bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_POOLE_SUBSTRUCTURE|BIAS_MODEL_POOLE_ZSPACE), bias_model(M_R,delta_c,z,&cosmo,BIAS_MODEL_POOLE_SUBSTRUCTURE|BIAS_MODEL_POOLE_TOTAL)); } } SID_log("Done.",SID_LOG_CLOSE); // Clean-up free_cosmo(&cosmo); SID_log("Done.",SID_LOG_CLOSE); SID_exit(ERROR_NONE); }
int main(int argc, char *argv[]) { SID_Init(&argc, &argv, NULL); // Parse arguments char filename_cosmo[SID_MAX_FILENAME_LENGTH]; char filename_list_in[SID_MAX_FILENAME_LENGTH]; strcpy(filename_cosmo, argv[1]); strcpy(filename_list_in, argv[2]); // Read input list char * line = NULL; size_t line_length = 0; FILE * fp_in = fopen(filename_list_in, "r"); int n_list = count_lines_data(fp_in); double *a_list = (double *)SID_malloc(sizeof(double) * n_list); for(int i_list = 0; i_list < n_list; i_list++) { grab_next_line_data(fp_in, &line, &line_length); grab_double(line, 1, &(a_list[i_list])); } SID_free(SID_FARG line); double a_lo_table = a_list[0]; double a_hi_table = a_list[n_list - 1]; for(int i_list = 0; i_list < n_list; i_list++) { a_lo_table = GBP_MIN(a_lo_table, a_list[i_list]); a_hi_table = GBP_MAX(a_hi_table, a_list[i_list]); } a_lo_table = GBP_MIN(a_lo_table, 1e-4); SID_log("Creating extended snapshot list...", SID_LOG_OPEN); // Initialize cosmology cosmo_info *cosmo = NULL; read_gbpCosmo_file(&cosmo, filename_cosmo); // Creeate interpolation tables int n_table = 500; double *a_table = (double *)SID_malloc(n_table * sizeof(double)); double *t_table = (double *)SID_malloc(n_table * sizeof(double)); double *n_dyn_table = (double *)SID_malloc(n_table * sizeof(double)); double da_table = (a_hi_table - a_lo_table) / (double)(n_table - 1); for(int i_table = 0; i_table < n_table; i_table++) { // Expansion factor if(i_table == 0) a_table[i_table] = a_lo_table; else if(i_table == (n_table - 1)) a_table[i_table] = a_hi_table; else a_table[i_table] = a_table[0] + da_table * (double)i_table; // Cosmic time t_table[i_table] = t_age_a(a_table[i_table], &cosmo); // Number of dynamical times if(i_table == 0) n_dyn_table[i_table] = 0.; else n_dyn_table[i_table] = delta_n_dyn(a_table[0], a_table[i_table], &cosmo); } interp_info *n_of_a_interp = NULL; init_interpolate(a_table, n_dyn_table, n_table, gsl_interp_akima, &n_of_a_interp); // Generate desired table double a_last = 0.; double z_last = 0.; double t_last = 0.; double n_last = 0.; double a_i = 0.; double z_i = 1.e22; double t_i = 0.; double n_i = 0.; double da = 0.; double dz = 0.; double dt = 0.; double dn = 0.; int i_column = 1; printf("# Table of times, etc. generated from expansion factors in {%s}\n", filename_list_in); printf("# Column (%02d): snapshot number\n", i_column++); printf("# (%02d): a:=expansion factor\n", i_column++); printf("# (%02d): da\n", i_column++); printf("# (%02d): z:=redshift\n", i_column++); printf("# (%02d): dz\n", i_column++); printf("# (%02d): t:=cosmic time [years]\n", i_column++); printf("# (%02d): dt\n", i_column++); printf("# (%02d): n_dyn:=No. of dynamical times\n", i_column++); printf("# (%02d): dn_dyn\n", i_column++); for(int i_list = 0; i_list < n_list; i_list++) { a_last = a_i; z_last = z_i; t_last = t_i; n_last = n_i; a_i = a_list[i_list]; z_i = z_of_a(a_i); t_i = t_age_a(a_i, &cosmo) / S_PER_YEAR; n_i = interpolate(n_of_a_interp, a_i); da = a_i - a_last; dz = fabs(z_i - z_last); dt = t_i - t_last; dn = n_i - n_last; printf("%03d %le %le %le %le %le %le %le %le\n", i_list, a_i, da, z_i, dz, t_i, dt, n_i, dn); } // Clean-up SID_free(SID_FARG a_list); SID_free(SID_FARG a_table); SID_free(SID_FARG t_table); SID_free(SID_FARG n_dyn_table); free_interpolate(SID_FARG n_of_a_interp, NULL); free_cosmo(&cosmo); SID_log("Done.", SID_LOG_CLOSE); SID_Finalize(); }
int main(int argc, char *argv[]){ int n_species; int n_load; int n_used; int flag_used[N_GADGET_TYPE]; char species_name[256]; double h_Hubble; double n_spec; double redshift; int i_species; char n_string[64]; int n[3]; double L[3]; FILE *fp_1D; FILE *fp_2D; cosmo_info *cosmo; field_info *field[N_GADGET_TYPE]; field_info *field_norm[N_GADGET_TYPE]; plist_info plist_header; plist_info plist; FILE *fp; int i_temp; int n_temp; double *k_temp; double *kmin_temp; double *kmax_temp; double *P_temp; size_t *n_mode_temp; double *sigma_P_temp; double *shot_noise_temp; double *dP_temp; int snapshot_number; int i_compute; int distribution_scheme; double k_min_1D; double k_max_1D; double k_min_2D; double k_max_2D; int n_k_1D; int n_k_2D; double *k_1D; double *P_k_1D; double *dP_k_1D; int *n_modes_1D; double *P_k_2D; double *dP_k_2D; int *n_modes_2D; int n_groups=1; double dk_1D; double dk_2D; char *grid_identifier; // Initialization -- MPI etc. SID_init(&argc,&argv,NULL,NULL); // Parse arguments int grid_size; char filename_in_root[MAX_FILENAME_LENGTH]; char filename_out_root[MAX_FILENAME_LENGTH]; strcpy(filename_in_root, argv[1]); snapshot_number=(int)atoi(argv[2]); strcpy(filename_out_root, argv[3]); grid_size =(int)atoi(argv[4]); if(!strcmp(argv[5],"ngp") || !strcmp(argv[5],"NGP")) distribution_scheme=MAP2GRID_DIST_NGP; else if(!strcmp(argv[5],"cic") || !strcmp(argv[5],"CIC")) distribution_scheme=MAP2GRID_DIST_CIC; else if(!strcmp(argv[5],"tsc") || !strcmp(argv[5],"TSC")) distribution_scheme=MAP2GRID_DIST_TSC; else if(!strcmp(argv[5],"d12") || !strcmp(argv[5],"D12")) distribution_scheme=MAP2GRID_DIST_DWT12; else if(!strcmp(argv[5],"d20") || !strcmp(argv[5],"D20")) distribution_scheme=MAP2GRID_DIST_DWT20; else SID_trap_error("Invalid distribution scheme {%s} specified.",ERROR_SYNTAX,argv[5]); SID_log("Smoothing Gadget file {%s;snapshot=#%d} to a %dx%dx%d grid with %s kernel...",SID_LOG_OPEN|SID_LOG_TIMER, filename_in_root,snapshot_number,grid_size,grid_size,grid_size,argv[5]); // Initialization -- fetch header info SID_log("Reading Gadget header...",SID_LOG_OPEN); gadget_read_info fp_gadget; int flag_filefound=init_gadget_read(filename_in_root,snapshot_number,&fp_gadget); int flag_multifile=fp_gadget.flag_multifile; int flag_file_type=fp_gadget.flag_file_type; gadget_header_info header =fp_gadget.header; double box_size =(double)(header.box_size); size_t *n_all =(size_t *)SID_calloc(sizeof(size_t)*N_GADGET_TYPE); size_t n_total; if(flag_filefound){ if(SID.I_am_Master){ FILE *fp_in; char filename[MAX_FILENAME_LENGTH]; int block_length_open; int block_length_close; set_gadget_filename(&fp_gadget,0,filename); fp_in=fopen(filename,"r"); fread_verify(&block_length_open, sizeof(int),1,fp_in); fread_verify(&header, sizeof(gadget_header_info),1,fp_in); fread_verify(&block_length_close,sizeof(int),1,fp_in); fclose(fp_in); if(block_length_open!=block_length_close) SID_trap_error("Block lengths don't match (ie. %d!=%d).",ERROR_LOGIC,block_length_open,block_length_close); } SID_Bcast(&header,sizeof(gadget_header_info),MASTER_RANK,SID.COMM_WORLD); redshift=header.redshift; h_Hubble=header.h_Hubble; box_size=header.box_size; if(SID.n_proc>1) n_load=1; else n_load=header.n_files; for(i_species=0,n_total=0,n_used=0;i_species<N_GADGET_TYPE;i_species++){ n_all[i_species]=(size_t)header.n_all_lo_word[i_species]+((size_t)header.n_all_hi_word[i_species])<<32; n_total+=n_all[i_species]; if(n_all[i_species]>0){ n_used++; flag_used[i_species]=TRUE; } else flag_used[i_species]=FALSE; } // Initialize cosmology double box_size =((double *)ADaPS_fetch(plist.data,"box_size"))[0]; double h_Hubble =((double *)ADaPS_fetch(plist.data,"h_Hubble"))[0]; double redshift =((double *)ADaPS_fetch(plist.data,"redshift"))[0]; double expansion_factor=((double *)ADaPS_fetch(plist.data,"expansion_factor"))[0]; double Omega_M =((double *)ADaPS_fetch(plist.data,"Omega_M"))[0]; double Omega_Lambda =((double *)ADaPS_fetch(plist.data,"Omega_Lambda"))[0]; double Omega_k =1.-Omega_Lambda-Omega_M; double Omega_b=0.; // not needed, so doesn't matter double f_gas =Omega_b/Omega_M; double sigma_8=0.; // not needed, so doesn't matter double n_spec =0.; // not needed, so doesn't matter char cosmo_name[16]; sprintf(cosmo_name,"Gadget file's"); init_cosmo(&cosmo, cosmo_name, Omega_Lambda, Omega_M, Omega_k, Omega_b, f_gas, h_Hubble, sigma_8, n_spec); } SID_log("Done.",SID_LOG_CLOSE); grid_identifier=(char *)SID_calloc(GRID_IDENTIFIER_SIZE*sizeof(char)); // Only process if there are >0 particles present if(n_used>0){ // Loop over ithe real-space and 3 redshift-space frames int i_write; int i_run; int n_run; int n_grids_total; n_grids_total=4; // For now, hard-wire real-space density and velocity grids only n_run=1; // For now, hard-wire real-space calculation only for(i_run=0,i_write=0;i_run<n_run;i_run++){ // Read catalog int n_grid; char i_run_identifier[8]; switch(i_run){ case 0: SID_log("Processing real-space ...",SID_LOG_OPEN|SID_LOG_TIMER); sprintf(i_run_identifier,"r"); n_grid=4; break; case 1: SID_log("Processing v_x redshift space...",SID_LOG_OPEN|SID_LOG_TIMER); sprintf(i_run_identifier,"x"); n_grid=1; break; case 2: SID_log("Processing v_y redshift space...",SID_LOG_OPEN|SID_LOG_TIMER); sprintf(i_run_identifier,"y"); n_grid=1; break; case 3: SID_log("Processing v_z redsift space...",SID_LOG_OPEN|SID_LOG_TIMER); sprintf(i_run_identifier,"z"); n_grid=1; break; } // For each i_run case, loop over the fields we want to produce int i_grid; for(i_grid=0;i_grid<n_grid;i_grid++){ char i_grid_identifier[8]; switch(i_grid){ case 0: SID_log("Processing density grid ...",SID_LOG_OPEN|SID_LOG_TIMER); sprintf(i_grid_identifier,"rho"); break; case 1: SID_log("Processing v_x velocity grid...",SID_LOG_OPEN|SID_LOG_TIMER); sprintf(i_grid_identifier,"v_x"); break; case 2: SID_log("Processing v_y velocity grid...",SID_LOG_OPEN|SID_LOG_TIMER); sprintf(i_grid_identifier,"v_y"); break; case 3: SID_log("Processing v_z velocity grid...",SID_LOG_OPEN|SID_LOG_TIMER); sprintf(i_grid_identifier,"v_z"); break; } // Initialize the field that will hold the grid int n[]={grid_size,grid_size,grid_size}; double L[]={box_size, box_size, box_size}; int i_init; for(i_species=0;i_species<N_GADGET_TYPE;i_species++){ if(flag_used[i_species]){ field[i_species] =(field_info *)SID_malloc(sizeof(field_info)); field_norm[i_species]=(field_info *)SID_malloc(sizeof(field_info)); init_field(3,n,L,field[i_species]); init_field(3,n,L,field_norm[i_species]); i_init=i_species; } else{ field[i_species] =NULL; field_norm[i_species]=NULL; } } // Loop over all the files that this rank will read int i_load; for(i_load=0;i_load<n_load;i_load++){ if(n_load>1) SID_log("Processing file No. %d of %d...",SID_LOG_OPEN|SID_LOG_TIMER,i_load+1,n_load); // Initialization -- read gadget file GBPREAL mass_array[N_GADGET_TYPE]; init_plist(&plist,&((field[i_init])->slab),GADGET_LENGTH,GADGET_MASS,GADGET_VELOCITY); char filename_root[MAX_FILENAME_LENGTH]; read_gadget_binary_local(filename_in_root, snapshot_number, i_run, i_load, n_load, mass_array, &(field[i_init]->slab), cosmo, &plist); // Generate power spectra for(i_species=0;i_species<plist.n_species;i_species++){ // Determine how many particles of species i_species there are if(n_all[i_species]>0){ // Fetch the needed information size_t n_particles; size_t n_particles_local; int flag_alloc_m; GBPREAL *x_particles_local; GBPREAL *y_particles_local; GBPREAL *z_particles_local; GBPREAL *vx_particles_local; GBPREAL *vy_particles_local; GBPREAL *vz_particles_local; GBPREAL *m_particles_local; GBPREAL *v_particles_local; GBPREAL *w_particles_local; n_particles =((size_t *)ADaPS_fetch(plist.data,"n_all_%s",plist.species[i_species]))[0]; n_particles_local=((size_t *)ADaPS_fetch(plist.data,"n_%s", plist.species[i_species]))[0]; x_particles_local= (GBPREAL *)ADaPS_fetch(plist.data,"x_%s", plist.species[i_species]); y_particles_local= (GBPREAL *)ADaPS_fetch(plist.data,"y_%s", plist.species[i_species]); z_particles_local= (GBPREAL *)ADaPS_fetch(plist.data,"z_%s", plist.species[i_species]); vx_particles_local=(GBPREAL *)ADaPS_fetch(plist.data,"vx_%s", plist.species[i_species]); vy_particles_local=(GBPREAL *)ADaPS_fetch(plist.data,"vy_%s", plist.species[i_species]); vz_particles_local=(GBPREAL *)ADaPS_fetch(plist.data,"vz_%s", plist.species[i_species]); if(ADaPS_exist(plist.data,"M_%s",plist.species[i_species])){ flag_alloc_m=FALSE; m_particles_local=(GBPREAL *)ADaPS_fetch(plist.data,"M_%s",plist.species[i_species]); } else{ flag_alloc_m=TRUE; m_particles_local=(GBPREAL *)SID_malloc(n_particles_local*sizeof(GBPREAL)); int i_particle; for(i_particle=0;i_particle<n_particles_local;i_particle++) m_particles_local[i_particle]=mass_array[i_species]; } // Decide the map_to_grid() mode int mode; if(n_load==1) mode=MAP2GRID_MODE_DEFAULT; else if(i_load==0 || n_load==1) mode=MAP2GRID_MODE_DEFAULT|MAP2GRID_MODE_NONORM; else if(i_load==(n_load-1)) mode=MAP2GRID_MODE_NOCLEAN; else mode=MAP2GRID_MODE_NOCLEAN|MAP2GRID_MODE_NONORM; // Set the array that will weight the grid field_info *field_i; field_info *field_norm_i; double factor; switch(i_grid){ case 0: v_particles_local=m_particles_local; w_particles_local=NULL; field_i =field[i_species]; field_norm_i =NULL; mode|=MAP2GRID_MODE_APPLYFACTOR; factor=pow((double)grid_size/box_size,3.); break; case 1: v_particles_local=vx_particles_local; w_particles_local=m_particles_local; field_i =field[i_species]; field_norm_i =field_norm[i_species]; factor=1.; break; case 2: v_particles_local=vy_particles_local; w_particles_local=m_particles_local; field_i =field[i_species]; field_norm_i =field_norm[i_species]; factor=1.; break; case 3: v_particles_local=vz_particles_local; w_particles_local=m_particles_local; field_i =field[i_species]; field_norm_i =field_norm[i_species]; factor=1.; break; } // Generate grid map_to_grid(n_particles_local, x_particles_local, y_particles_local, z_particles_local, v_particles_local, w_particles_local, cosmo, redshift, distribution_scheme, factor, field_i, field_norm_i, mode); if(flag_alloc_m) SID_free(SID_FARG m_particles_local); } } // Clean-up free_plist(&plist); if(n_load>1) SID_log("Done.",SID_LOG_CLOSE); } // loop over i_load // Write results to disk char filename_out_species[MAX_FILENAME_LENGTH]; init_plist(&plist,NULL,GADGET_LENGTH,GADGET_MASS,GADGET_VELOCITY); for(i_species=0;i_species<plist.n_species;i_species++){ if(flag_used[i_species]){ sprintf(grid_identifier,"%s_%s_%s",i_grid_identifier,i_run_identifier,plist.species[i_species]); sprintf(filename_out_species,"%s_%s",filename_out_root,plist.species[i_species]); write_grid(field[i_species], filename_out_species, i_write, n_grids_total, distribution_scheme, grid_identifier, header.box_size); free_field(field[i_species]); free_field(field_norm[i_species]); SID_free(SID_FARG field[i_species]); SID_free(SID_FARG field_norm[i_species]); i_write++; } } // Clean-up free_plist(&plist); SID_log("Done.",SID_LOG_CLOSE); } // loop over i_grid SID_log("Done.",SID_LOG_CLOSE); } // loop over i_run } // if n_used>0 // Clean-up free_cosmo(&cosmo); SID_free(SID_FARG grid_identifier); SID_free(SID_FARG n_all); SID_log("Done.",SID_LOG_CLOSE); SID_exit(ERROR_NONE); }