int main(int argc, char* argv[]) { char *mosaic_file = NULL, *topog_file = NULL, *topog_field = NULL; char topog_type[32] = "realistic", topog_mosaic[128] = "topog_mosaic"; char output_file[256]; int num_filter_pass = 1; int x_refine = 2, y_refine = 2; double basin_depth = 5000, bottom_depth = 5000, min_depth = 10, scale_factor = 1; double gauss_amp = 0.5, gauss_scale = 0.25, slope_x = 0, slope_y = 0; double bowl_south = 60, bowl_north = 70, bowl_west = 0, bowl_east = 20; int flat_bottom = 0, fill_first_row = 0; int filter_topog = 0, round_shallow = 0, fill_shallow = 0; int deepen_shallow = 0, smooth_topo_allow_deepening = 0; int errflg = (argc == 1); int option_index, i, c; /* * process command line */ static struct option long_options[] = { {"mosaic", required_argument, NULL, 'a'}, {"topog_type", required_argument, NULL, 'b'}, {"x_refine", required_argument, NULL, 'X'}, {"y_refine", required_argument, NULL, 'Y'}, {"basin_depth", required_argument, NULL, 'c'}, {"topog_file", required_argument, NULL, 'd'}, {"topog_field", required_argument, NULL, 'e'}, {"bottom_depth", required_argument, NULL, 'f'}, {"min_depth", required_argument, NULL, 'g'}, {"scale_factor", required_argument, NULL, 'i'}, {"num_filter_pass", required_argument, NULL, 'j'}, {"gauss_amp", required_argument, NULL, 'k'}, {"gauss_scale", required_argument, NULL, 'l'}, {"slope_x", required_argument, NULL, 'm'}, {"slope_y", required_argument, NULL, 'n'}, {"bowl_south", required_argument, NULL, 'p'}, {"bowl_north", required_argument, NULL, 'q'}, {"bowl_west", required_argument, NULL, 'r'}, {"bowl_east", required_argument, NULL, 's'}, {"fill_first_row", no_argument, NULL, 't'}, {"filter_topog", no_argument, NULL, 'u'}, {"round_shallow", no_argument, NULL, 'v'}, {"fill_shallow", no_argument, NULL, 'w'}, {"deepen_shallow", no_argument, NULL, 'x'}, {"smooth_topo_allow_deepening", no_argument, NULL, 'y'}, {"topog_mosaic", required_argument, NULL, 'o'}, {"help", no_argument, NULL, 'h'}, {0, 0, 0, 0}, }; /* start parallel */ mpp_init(&argc, &argv); mpp_domain_init(); while ((c = getopt_long(argc, argv, "", long_options, &option_index)) != -1) switch (c) { case 'a': mosaic_file = optarg; break; case 'b': strcpy(topog_type, optarg); break; case 'X': x_refine = atoi(optarg); break; case 'Y': y_refine = atoi(optarg); break; case 'c': basin_depth = atof(optarg); break; case 'd': topog_file = optarg; break; case 'e': topog_field = optarg; break; case 'f': bottom_depth = atof(optarg); break; case 'g': min_depth = atof(optarg); break; case 'i': scale_factor = atof(optarg); break; case 'j': num_filter_pass = atoi(optarg); break; case 'k': gauss_amp = atof(optarg); break; case 'l': gauss_scale = atof(optarg); break; case 'm': slope_x = atof(optarg); break; case 'n': slope_y = atof(optarg); break; case 'p': bowl_south = atof(optarg); break; case 'q': bowl_north = atof(optarg); break; case 'r': bowl_west = atof(optarg); break; case 's': bowl_east = atof(optarg); break; case 't': fill_first_row = 1; break; case 'u': filter_topog = 1; break; case 'v': round_shallow = 1; break; case 'w': fill_shallow = 1; break; case 'x': deepen_shallow = 1; break; case 'y': smooth_topo_allow_deepening = 1; break; case 'o': strcpy(topog_mosaic,optarg); break; case '?': errflg++; break; } if (errflg || !mosaic_file ) { char **u = usage; while (*u) { fprintf(stderr, "%s\n", *u); u++; } exit(2); } /* Write out arguments value */ if(mpp_pe() == mpp_root_pe()) printf("NOTE from make_topog ==> the topog_type is: %s\n",topog_type); if(x_refine != 2 || y_refine != 2 ) mpp_error("Error from make_topog: x_refine and y_refine should be 2, contact developer"); if(mpp_pe() == mpp_root_pe()) printf("NOTE from make_topog ==> x_refine is %d, y_refine is %d\n", x_refine, y_refine); if (strcmp(topog_type,"rectangular_basin") == 0) { if(mpp_pe() == mpp_root_pe()) printf("NOTE from make_topog ==> the basin depth is %f\n",basin_depth); } else if (strcmp(topog_type,"gaussian") == 0) { if(mpp_pe() == mpp_root_pe()){ printf("NOTE from make_topog ==> bottom_depth is: %f\n", bottom_depth ); printf("NOTE from make_topog ==> min_depth is: %f\n", min_depth ); printf("NOTE from make_topog ==> gauss_amp is: %f\n", gauss_amp ); printf("NOTE from make_topog ==> gauss_scale is: %f\n", gauss_scale ); printf("NOTE from make_topog ==> slope_x is: %f\n", slope_x ); printf("NOTE from make_topog ==> slope_y is: %f\n", slope_y ); } } else if(strcmp(topog_type,"bowl") == 0) { if(mpp_pe() == mpp_root_pe()){ printf("NOTE from make_topog ==> bottom_depth is: %f\n",bottom_depth); printf("NOTE from make_topog ==> min_depth is: %f\n",min_depth); printf("NOTE from make_topog ==> bowl_south is: %f\n",bowl_south); printf("NOTE from make_topog ==> bowl_north is: %f\n",bowl_north); printf("NOTE from make_topog ==> bowl_west is: %f\n",bowl_west); printf("NOTE from make_topog ==> bowl_east is: %f\n",bowl_east); } } else if(strcmp(topog_type,"idealized") == 0) { if(mpp_pe() == mpp_root_pe()){ printf("NOTE from make_topog ==> bottom_depth is: %f\n",bottom_depth); printf("NOTE from make_topog ==> min_depth is: %f\n",min_depth); } } else if(strcmp(topog_type,"realistic") == 0) { if(!topog_file || !topog_field) mpp_error("Error from make_topog: when topog_type is realistic, topog_file and topog_field must be specified."); if(mpp_pe() == mpp_root_pe()){ printf("NOTE from make_topog ==> bottom_depth is: %f\n",bottom_depth); printf("NOTE from make_topog ==> min_depth is: %f\n",min_depth); printf("NOTE from make_topog ==> topog_file is: %s\n", topog_file); printf("NOTE from make_topog ==> topog_field is: %s\n", topog_field); printf("NOTE from make_topog ==> scale_factor is: %f\n", scale_factor); printf("NOTE from make_topog ==> num_filter_pass is: %d\n", num_filter_pass); if(fill_first_row) printf("NOTE from make_topog ==>make first row of ocean model all land points.\n"); if(filter_topog) printf("NOTE from make_topog ==>will apply filter to topography.\n"); if(round_shallow) printf("NOTE from make_topog ==>Make cells land if depth is less than 1/2 " "mimumim depth, otherwise make ocean.\n"); if(fill_shallow) printf("NOTE from make_topog ==>Make cells less than minimum depth land.\n"); if(deepen_shallow) printf("NOTE from make_topog ==>Make cells less than minimum depth equal to minimum depth.\n"); if(smooth_topo_allow_deepening) printf("NOTE from make_topog ==>allow filter to deepen cells.\n"); } } else { mpp_error("make_topog: topog_type should be rectangular_basin, gaussian, bowl, idealized or realistic"); } if(mpp_pe() == mpp_root_pe()) { printf("**************************************************\n"); printf("Begin to generate topography \n"); } { int m_fid, g_fid, vid; int ntiles, fid, dim_ntiles, n, dims[2]; size_t start[4], nread[4], nwrite[4]; int *nx, *ny, *nxp, *nyp; int *id_depth; double *depth, *x, *y; int *t_fid; int dim_nchild, dim_string, id_mosaic, id_childfile; char **tile_files, **topog_files; char history[512]; char gridfile[256], griddir[256]; /* history will be write out as global attribute in output file to specify the command line arguments */ strcpy(history,argv[0]); for(i=1;i<argc;i++) { strcat(history, " "); strcat(history, argv[i]); } /* grid should be located in the same directory of mosaic file */ get_file_path(mosaic_file, griddir); /* get mosaic dimension */ m_fid = mpp_open(mosaic_file, MPP_READ); ntiles = mpp_get_dimlen( m_fid, "ntiles"); tile_files = (char **)malloc(ntiles*sizeof(char *)); topog_files = (char **)malloc(ntiles*sizeof(char *)); t_fid = (int *) malloc(ntiles*sizeof(int )); id_depth = (int *)malloc(ntiles*sizeof(int)); /* loop through each tile to get tile information and set up meta data for output file */ sprintf(output_file, "%s.nc", topog_mosaic); fid = mpp_open(output_file, MPP_WRITE); mpp_def_global_att(fid, GRID_VERSION_NAME, grid_version); mpp_def_global_att(fid, CODE_VERSION_NAME, tagname); mpp_def_global_att(fid, HISTORY_NAME, history); dim_nchild = mpp_def_dim(fid, NTILES_NAME, ntiles); dim_string = mpp_def_dim(fid, STRING_NAME, STRING); id_mosaic = mpp_def_var(fid, MOSAIC_FILES_NAME, MPP_CHAR, 1, &dim_string, 1, "standard_name", "grid_mosaic_files"); dims[0] = dim_nchild; dims[1] = dim_string; id_childfile = mpp_def_var(fid, TILE_FILES_NAME, MPP_CHAR, 2, dims, 0); mpp_end_def(fid); nx = (int *)malloc(ntiles*sizeof(int)); ny = (int *)malloc(ntiles*sizeof(int)); nxp = (int *)malloc(ntiles*sizeof(int)); nyp = (int *)malloc(ntiles*sizeof(int)); for( n = 0; n < ntiles; n++ ) { char tile_name[128]; tile_files[n] = (char *)malloc(STRING*sizeof(double)); topog_files[n] = (char *)malloc(STRING*sizeof(double)); start[0] = n; start[1] = 0; nread[0] = 1; nread[1] = STRING; vid = mpp_get_varid(m_fid, TILE_FILES_NAME); mpp_get_var_value_block(m_fid, vid, start, nread, gridfile); sprintf(tile_files[n], "%s/%s", griddir, gridfile); g_fid = mpp_open(tile_files[n], MPP_READ); vid = mpp_get_varid(g_fid, "tile"); mpp_get_var_value(g_fid, vid, tile_name); sprintf(topog_files[n],"%s.%s.nc", topog_mosaic, tile_name); nx[n] = mpp_get_dimlen(g_fid, "nx"); ny[n] = mpp_get_dimlen(g_fid, "ny"); if( nx[n]%x_refine != 0 ) mpp_error("make_topog: supergrid x-size can not be divided by x_refine"); if( ny[n]%y_refine != 0 ) mpp_error("make_topog: supergrid y-size can not be divided by y_refine"); nx[n] /= x_refine; ny[n] /= y_refine; nxp[n] = nx[n] + 1; nyp[n] = ny[n] + 1; t_fid[n] = mpp_open(topog_files[n], MPP_WRITE); mpp_def_global_att(t_fid[n], GRID_VERSION_NAME, grid_version); mpp_def_global_att(t_fid[n], CODE_VERSION_NAME, tagname); mpp_def_global_att(t_fid[n], HISTORY_NAME, history); dims[1] = mpp_def_dim(t_fid[n], NX_NAME, nx[n]); dims[0] = mpp_def_dim(t_fid[n], NY_NAME, ny[n]); id_depth[n] = mpp_def_var(t_fid[n], DEPTH_NAME, NC_DOUBLE, 2, dims, 2, "standard_name", "topographic depth at T-cell centers", "units", "meters"); mpp_close(g_fid); mpp_end_def(t_fid[n]); } mpp_close(m_fid); /* Generate topography and write out to the output_file */ for(n=0; n<ntiles; n++) { int layout[2], isc, iec, jsc, jec, nxc, nyc, ni, i, j; double *gdata, *tmp; domain2D domain; /* define the domain, each tile will be run on all the processors. */ mpp_define_layout( nx[n], ny[n], mpp_npes(), layout); mpp_define_domain2d( nx[n], ny[n], layout, 0, 0, &domain); mpp_get_compute_domain2d( domain, &isc, &iec, &jsc, &jec); nxc = iec - isc + 1; nyc = jec - jsc + 1; depth = (double *)malloc(nxc*nyc*sizeof(double)); x = (double *)malloc((nxc+1)*(nyc+1)*sizeof(double)); y = (double *)malloc((nxc+1)*(nyc+1)*sizeof(double)); tmp = (double *)malloc((nxc*x_refine+1)*(nyc*y_refine+1)*sizeof(double)); start[0] = jsc*y_refine; start[1] = isc*x_refine; nread[0] = nyc*y_refine+1; nread[1] = nxc*x_refine+1; ni = nxc*x_refine+1; g_fid = mpp_open(tile_files[n], MPP_READ); vid = mpp_get_varid(g_fid, "x"); mpp_get_var_value_block(g_fid, vid, start, nread, tmp); for(j = 0; j < nyc+1; j++) for(i = 0; i < nxc+1; i++) x[j*(nxc+1)+i] = tmp[(j*y_refine)*ni+i*x_refine]; vid = mpp_get_varid(g_fid, "y"); mpp_get_var_value_block( g_fid, vid, start, nread, tmp); mpp_close(g_fid); for(j = 0; j < nyc+1; j++) for(i = 0; i < nxc+1; i++) y[j*(nxc+1)+i] = tmp[(j*y_refine)*ni+i*x_refine]; if (strcmp(topog_type,"rectangular_basin") == 0) create_rectangular_topog(nx[n], ny[n], basin_depth, depth); else if (strcmp(topog_type,"gaussian") == 0) create_gaussian_topog(nx[n], ny[n], x, y, bottom_depth, min_depth, gauss_amp, gauss_scale, slope_x, slope_y, depth); else if (strcmp(topog_type,"bowl") == 0) create_bowl_topog(nx[n], ny[n], x, y, bottom_depth, min_depth, bowl_east, bowl_south, bowl_west, bowl_north, depth); else if (strcmp(topog_type,"idealized") == 0) create_idealized_topog( nx[n], ny[n], x, y, bottom_depth, min_depth, depth); else if (strcmp(topog_type,"realistic") == 0) create_realistic_topog(nxc, nyc, x, y, topog_file, topog_field, scale_factor, fill_first_row, filter_topog, num_filter_pass, smooth_topo_allow_deepening, round_shallow, fill_shallow, deepen_shallow, min_depth, depth ); gdata = (double *)malloc(nx[n]*ny[n]*sizeof(double)); mpp_global_field_double(domain, nxc, nyc, depth, gdata); mpp_put_var_value(t_fid[n], id_depth[n], gdata); free(x); free(y); free(tmp); free(depth); free(gdata); mpp_delete_domain2d(&domain); mpp_close(t_fid[n]); } for(i=0; i<4; i++) { start[i] = 0; nwrite[i] = 1; } nwrite[0] = strlen(mosaic_file); mpp_put_var_value_block(fid, id_mosaic, start, nwrite, mosaic_file); nwrite[0] = 1; for(n=0; n<ntiles; n++) { start[0]=n; nwrite[1]=strlen(topog_files[n]); mpp_put_var_value_block(fid, id_childfile, start, nwrite, topog_files[n]); } mpp_close(fid); /*release memory */ free(id_depth); for(n=0; n<ntiles; n++) { free(tile_files[n]); free(topog_files[n]); } free(tile_files); free(topog_files); free(t_fid); free(nx); free(ny); free(nxp); free(nyp); } if(mpp_pe() == mpp_root_pe() ) printf("Successfully generate %s\n",output_file); mpp_end(); return 0; }; //main
int main(int argc, char* argv[]) { char *mosaic_file = NULL, *topog_file = NULL, *topog_field = NULL; char topog_type[32] = "realistic", output_file[32] = "topog.nc"; int num_filter_pass = 1; int x_refine = 2, y_refine = 2; double bottom_depth = 5000, min_depth = 10, scale_factor = 1; double gauss_amp = 0.5, gauss_scale = 0.25, slope_x = 0, slope_y = 0; double bowl_south = 60, bowl_north = 70, bowl_west = 0, bowl_east = 20; int flat_bottom = 0, fill_first_row = 0; int filter_topog = 0, round_shallow = 0, fill_shallow = 0; int deepen_shallow = 0, smooth_topo_allow_deepening = 0; int jwest_south=0, jwest_north=0, jeast_south=0, jeast_north=0; double dome_slope=0.01; double dome_bottom=3600.0; double dome_embayment_west=19.0; double dome_embayment_east=21.0; double dome_embayment_south=69.0; double dome_embayment_depth=600.0; char *vgrid_file = NULL; int full_cell = 0; int fill_isolated_cells = 1; int dont_change_landmask = 0; int kmt_min = 2; int adjust_topo = 1; double fraction_full_cell = 0.2; int open_very_this_cell = 1; double min_thickness = 0.1; int my_topog_type; int use_great_circle_algorithm=0; int cyclic_x, cyclic_y, tripolar_grid; int errflg = (argc == 1); int option_index, i, c; unsigned int verbose = 0; /* * process command line */ static struct option long_options[] = { {"mosaic", required_argument, NULL, 'a'}, {"topog_type", required_argument, NULL, 'b'}, {"x_refine", required_argument, NULL, 'X'}, {"y_refine", required_argument, NULL, 'Y'}, {"topog_file", required_argument, NULL, 'd'}, {"topog_field", required_argument, NULL, 'e'}, {"bottom_depth", required_argument, NULL, 'f'}, {"min_depth", required_argument, NULL, 'g'}, {"scale_factor", required_argument, NULL, 'i'}, {"num_filter_pass", required_argument, NULL, 'j'}, {"gauss_amp", required_argument, NULL, 'k'}, {"gauss_scale", required_argument, NULL, 'l'}, {"slope_x", required_argument, NULL, 'm'}, {"slope_y", required_argument, NULL, 'n'}, {"bowl_south", required_argument, NULL, 'p'}, {"bowl_north", required_argument, NULL, 'q'}, {"bowl_west", required_argument, NULL, 'r'}, {"bowl_east", required_argument, NULL, 's'}, {"fill_first_row", no_argument, NULL, 't'}, {"filter_topog", no_argument, NULL, 'u'}, {"round_shallow", no_argument, NULL, 'v'}, {"fill_shallow", no_argument, NULL, 'w'}, {"deepen_shallow", no_argument, NULL, 'x'}, {"smooth_topo_allow_deepening", no_argument, NULL, 'y'}, {"output", required_argument, NULL, 'o'}, {"jwest_south", required_argument, NULL, 'A'}, {"jwest_north", required_argument, NULL, 'B'}, {"jeast_south", required_argument, NULL, 'C'}, {"jeast_north", required_argument, NULL, 'D'}, {"dome_slope", required_argument, NULL, 'E'}, {"dome_bottom", required_argument, NULL, 'F'}, {"dome_embayment_west", required_argument, NULL, 'G'}, {"dome_embayment_east", required_argument, NULL, 'H'}, {"dome_embayment_south", required_argument, NULL, 'I'}, {"dome_embayment_depth", required_argument, NULL, 'J'}, {"vgrid_file", required_argument, NULL, 'K'}, {"flat_bottom", no_argument, NULL, 'L'}, {"full_cell", no_argument, NULL, 'M'}, {"dont_fill_isolated_cells", no_argument, NULL, 'N'}, {"dont_change_landmask", no_argument, NULL, 'O'}, {"kmt_min", required_argument, NULL, 'P'}, {"dont_adjust_topo", no_argument, NULL, 'Q'}, {"fraction_full_cell", required_argument, NULL, 'R'}, {"dont_open_very_this_cell", no_argument, NULL, 'S'}, {"min_thickness", required_argument, NULL, 'T'}, {"help", no_argument, NULL, 'h'}, {"verbose", no_argument, NULL, 'V'}, {0, 0, 0, 0}, }; /* start parallel */ mpp_init(&argc, &argv); mpp_domain_init(); while ((c = getopt_long(argc, argv, "", long_options, &option_index)) != -1) switch (c) { case 'a': mosaic_file = optarg; break; case 'b': strcpy(topog_type, optarg); break; case 'X': x_refine = atoi(optarg); break; case 'Y': y_refine = atoi(optarg); break; case 'd': topog_file = optarg; break; case 'e': topog_field = optarg; break; case 'f': bottom_depth = atof(optarg); break; case 'g': min_depth = atof(optarg); break; case 'i': scale_factor = atof(optarg); break; case 'j': num_filter_pass = atoi(optarg); break; case 'k': gauss_amp = atof(optarg); break; case 'l': gauss_scale = atof(optarg); break; case 'm': slope_x = atof(optarg); break; case 'n': slope_y = atof(optarg); break; case 'p': bowl_south = atof(optarg); break; case 'q': bowl_north = atof(optarg); break; case 'r': bowl_west = atof(optarg); break; case 's': bowl_east = atof(optarg); break; case 't': fill_first_row = 1; break; case 'u': filter_topog = 1; break; case 'v': round_shallow = 1; break; case 'w': fill_shallow = 1; break; case 'x': deepen_shallow = 1; break; case 'y': smooth_topo_allow_deepening = 1; break; case 'o': strcpy(output_file,optarg); break; case 'A': jwest_south = atoi(optarg); break; case 'B': jwest_north = atoi(optarg); break; case 'C': jeast_south = atoi(optarg); break; case 'D': jeast_north = atoi(optarg); break; case 'E': dome_slope = atof(optarg); break; case 'F': dome_bottom = atof(optarg); break; case 'G': dome_embayment_west = atof(optarg); break; case 'H': dome_embayment_east = atof(optarg); break; case 'I': dome_embayment_south = atof(optarg); break; case 'J': dome_embayment_depth = atof(optarg); break; case 'K': vgrid_file = optarg; break; case 'L': flat_bottom = 1; break; case 'M': full_cell = 1; break; case 'N': fill_isolated_cells = 0; break; case 'O': dont_change_landmask = 1; break; case 'P': kmt_min = atoi(optarg); break; case 'Q': adjust_topo = 0; break; case 'R': fraction_full_cell = atof(optarg); break; case 'S': open_very_this_cell = 0; break; case 'T': min_thickness = atof(optarg); break; case 'V': verbose = 1; break; case '?': errflg++; break; } if (errflg || !mosaic_file ) { if( mpp_pe() == mpp_root_pe() ) { char **u = usage; while (*u) { fprintf(stderr, "%s\n", *u); u++; } mpp_error("make_topog: Check your arguments"); } } /* Write out arguments value */ if(mpp_pe() == mpp_root_pe() && verbose) printf("NOTE from make_topog ==> the topog_type is: %s\n",topog_type); if(x_refine != 2 || y_refine != 2 ) mpp_error("Error from make_topog: x_refine and y_refine should be 2, contact developer"); if(mpp_pe() == mpp_root_pe() && verbose) printf("NOTE from make_topog ==> x_refine is %d, y_refine is %d\n", x_refine, y_refine); /* vgrid_file can only be passed in when topog_type is realistic */ if(vgrid_file && strcmp(topog_type,"realistic")) mpp_error("make_topog: --vgrid_file should not be specified when topog_type = realistic"); if (strcmp(topog_type,"rectangular_basin") == 0) { my_topog_type = RECTANGULAR_BASIN; if(mpp_pe() == mpp_root_pe() && verbose) printf("NOTE from make_topog ==> the basin depth is %f\n",bottom_depth); } else if (strcmp(topog_type,"gaussian") == 0) { my_topog_type = GAUSSIAN; if(mpp_pe() == mpp_root_pe() && verbose){ printf("NOTE from make_topog ==> bottom_depth is: %f\n", bottom_depth ); printf("NOTE from make_topog ==> min_depth is: %f\n", min_depth ); printf("NOTE from make_topog ==> gauss_amp is: %f\n", gauss_amp ); printf("NOTE from make_topog ==> gauss_scale is: %f\n", gauss_scale ); printf("NOTE from make_topog ==> slope_x is: %f\n", slope_x ); printf("NOTE from make_topog ==> slope_y is: %f\n", slope_y ); } } else if(strcmp(topog_type,"bowl") == 0) { my_topog_type = BOWL; if(mpp_pe() == mpp_root_pe() && verbose){ printf("NOTE from make_topog ==> bottom_depth is: %f\n",bottom_depth); printf("NOTE from make_topog ==> min_depth is: %f\n",min_depth); printf("NOTE from make_topog ==> bowl_south is: %f\n",bowl_south); printf("NOTE from make_topog ==> bowl_north is: %f\n",bowl_north); printf("NOTE from make_topog ==> bowl_west is: %f\n",bowl_west); printf("NOTE from make_topog ==> bowl_east is: %f\n",bowl_east); } } else if(strcmp(topog_type,"idealized") == 0) { my_topog_type = IDEALIZED; if(mpp_pe() == mpp_root_pe() && verbose){ printf("NOTE from make_topog ==> bottom_depth is: %f\n",bottom_depth); printf("NOTE from make_topog ==> min_depth is: %f\n",min_depth); } } else if(strcmp(topog_type,"realistic") == 0) { my_topog_type = REALISTIC; if(!topog_file || !topog_field) mpp_error("Error from make_topog: when topog_type is realistic, topog_file and topog_field must be specified."); if(mpp_pe() == mpp_root_pe() && verbose){ printf("\n\n ************************************************************\n\n"); printf("NOTE from make_topog ==> input arguments\n\n"); printf("NOTE from make_topog ==> min_depth is: %f\n",min_depth); printf("NOTE from make_topog ==> topog_file is: %s\n", topog_file); printf("NOTE from make_topog ==> topog_field is: %s\n", topog_field); printf("NOTE from make_topog ==> scale_factor is: %f\n", scale_factor); printf("NOTE from make_topog ==> num_filter_pass is: %d\n", num_filter_pass); printf("NOTE from make_topog ==> kmt_min is %d\n", kmt_min); printf("NOTE from make_topog ==> fraction_full_cell is %f\n", fraction_full_cell); printf("NOTE from make_topog ==> min_thickness is %f\n", min_thickness); if(vgrid_file) printf("NOTE from make_topog ==> vgrid_file is %s\n", vgrid_file); else printf("NOTE from make_topog ==> no vgrid_file is specified\n"); if(fill_first_row) printf("NOTE from make_topog ==>make first row of ocean model all land points.\n"); if(filter_topog) printf("NOTE from make_topog ==>will apply filter to topography.\n"); if(round_shallow) printf("NOTE from make_topog ==>Make cells land if depth is less than 1/2 " "mimumim depth, otherwise make ocean.\n"); if(fill_shallow) printf("NOTE from make_topog ==>Make cells less than minimum depth land.\n"); if(deepen_shallow) printf("NOTE from make_topog ==>Make cells less than minimum depth equal to minimum depth.\n"); if(smooth_topo_allow_deepening) printf("NOTE from make_topog ==>allow filter to deepen cells.\n"); if(flat_bottom) printf("NOTE from make_topog ==> generate flat bottom over ocean points.\n"); if(full_cell) printf("NOTE from make_topog ==> not generate partial bottom cells.\n"); if(fill_isolated_cells) printf("NOTE from make_topog ==> not allow non-advective tracer cells\n"); if(dont_change_landmask) printf("NOTE from make_topog ==> not change land/sea mask when filling isolated cells\n"); if(open_very_this_cell) printf("NOTE from make_topog ==> open this cell\n"); if(adjust_topo) printf("NOTE from make_topog ==> adjust topography\n"); printf("\n\n ************************************************************\n\n"); } } else if(strcmp(topog_type,"box_channel") == 0) { my_topog_type = BOX_CHANNEL; if( jwest_south <= 0) mpp_error("make_topog: jwest_south must a positive integer when topog_type = box_channel"); if( jwest_north <= 0) mpp_error("make_topog: jwest_north must a positive integer when topog_type = box_channel"); if( jeast_south <= 0) mpp_error("make_topog: jeast_south must a positive integer when topog_type = box_channel"); if( jeast_north <= 0) mpp_error("make_topog: jeast_north must a positive integer when topog_type = box_channel"); if( jwest_south > jwest_north ) mpp_error("make_topog: jwest_south > jwest_north when topog_type = box_channel"); if( jeast_south > jeast_north ) mpp_error("make_topog: jeast_south > jeast_north when topog_type = box_channel"); } else if(strcmp(topog_type,"dome") == 0) { my_topog_type = DOME; } else { mpp_error("make_topog: topog_type should be rectangular_basin, gaussian, bowl, idealized, realistic, box_channel or dome"); } if(mpp_pe() == mpp_root_pe() && verbose) { printf("**************************************************\n"); printf("Begin to generate topography \n"); } { const int STRING = 255; int m_fid, g_fid, vid; int ntiles, fid, dim_ntiles, n, dims[2]; size_t start[4], nread[4], nwrite[4]; int *nx=NULL, *ny=NULL, *nxp=NULL, *nyp=NULL; int *id_depth=NULL, *id_level=NULL; double *depth=NULL, *x=NULL, *y=NULL; int *num_levels=NULL; char **tile_files=NULL; char history[512], dimx_name[128], dimy_name[128], depth_name[128], level_name[128]; char gridfile[256], griddir[256]; /* history will be write out as global attribute in output file to specify the command line arguments */ strcpy(history,argv[0]); for(i=1;i<argc;i++) { strcat(history, " "); strcat(history, argv[i]); } /* grid should be located in the same directory of mosaic file */ get_file_path(mosaic_file, griddir); /* get mosaic dimension */ m_fid = mpp_open(mosaic_file, MPP_READ); ntiles = mpp_get_dimlen( m_fid, "ntiles"); tile_files = (char **)malloc(ntiles*sizeof(double *)); id_depth = (int *)malloc(ntiles*sizeof(int)); id_level = (int *)malloc(ntiles*sizeof(int)); /* loop through each tile to get tile information and set up meta data for output file */ fid = mpp_open(output_file, MPP_WRITE); dim_ntiles = mpp_def_dim(fid, "ntiles", ntiles); nx = (int *)malloc(ntiles*sizeof(int)); ny = (int *)malloc(ntiles*sizeof(int)); nxp = (int *)malloc(ntiles*sizeof(int)); nyp = (int *)malloc(ntiles*sizeof(int)); for( n = 0; n < ntiles; n++ ) { int use_great_circle_algorithm_prev=0; tile_files[n] = (char *)malloc(STRING*sizeof(double)); start[0] = n; start[1] = 0; nread[0] = 1; nread[1] = STRING; vid = mpp_get_varid(m_fid, "gridfiles"); mpp_get_var_value_block(m_fid, vid, start, nread, gridfile); sprintf(tile_files[n], "%s/%s", griddir, gridfile); g_fid = mpp_open(tile_files[n], MPP_READ); nx[n] = mpp_get_dimlen(g_fid, "nx"); ny[n] = mpp_get_dimlen(g_fid, "ny"); if( nx[n]%x_refine != 0 ) mpp_error("make_topog: supergrid x-size can not be divided by x_refine"); if( ny[n]%y_refine != 0 ) mpp_error("make_topog: supergrid y-size can not be divided by y_refine"); nx[n] /= x_refine; ny[n] /= y_refine; nxp[n] = nx[n] + 1; nyp[n] = ny[n] + 1; if(ntiles == 1) { strcpy(dimx_name, "nx"); strcpy(dimy_name, "ny"); strcpy(depth_name, "depth"); if(vgrid_file)strcpy(level_name, "num_levels"); } else { sprintf(dimx_name, "nx_tile%d", n+1); sprintf(dimy_name, "ny_tile%d", n+1); sprintf(depth_name, "depth_tile%d", n+1); if(vgrid_file)sprintf(level_name, "num_levels_tile%d", n+1); } dims[1] = mpp_def_dim(fid, dimx_name, nx[n]); dims[0] = mpp_def_dim(fid, dimy_name, ny[n]); id_depth[n] = mpp_def_var(fid, depth_name, NC_DOUBLE, 2, dims, 2, "standard_name", "topographic depth at T-cell centers", "units", "meters"); if(vgrid_file) id_level[n] = mpp_def_var(fid, level_name, NC_INT, 2, dims, 2, "standard_name", "number of vertical T-cells", "units", "none"); /* when topog_type is realistics, check if use great_circle_algorithm */ use_great_circle_algorithm = get_great_circle_algorithm(g_fid); if(n>0) { if( use_great_circle_algorithm != use_great_circle_algorithm_prev) mpp_error("make_topog: atribute 'great_circle_algorithm' of field 'tile' have different value for different tile"); } use_great_circle_algorithm_prev = use_great_circle_algorithm; mpp_close(g_fid); } mpp_close(m_fid); mpp_def_global_att(fid, "grid_version", grid_version); mpp_def_global_att(fid, "code_version", tagname); if(use_great_circle_algorithm) mpp_def_global_att(fid, "great_circle_algorithm", "TRUE"); mpp_def_global_att(fid, "history", history); mpp_end_def(fid); if(mpp_pe()==mpp_root_pe() && use_great_circle_algorithm) printf("\n NOTE from make_topog: use great circle algorithm\n"); /* get the boundary condition for realistics topogrpahy, currently only support tripolar_grid, cyclic_x and cyclic_y*/ if(my_topog_type == REALISTIC) get_boundary_type(mosaic_file, VERSION_2, &cyclic_x, &cyclic_y, &tripolar_grid); /* Generate topography and write out to the output_file */ for(n=0; n<ntiles; n++) { int layout[2], isc, iec, jsc, jec, nxc, nyc, ni, i, j; double *gdata=NULL, *tmp=NULL; domain2D domain; /* define the domain, each tile will be run on all the processors. */ mpp_define_layout( nx[n], ny[n], mpp_npes(), layout); mpp_define_domain2d( nx[n], ny[n], layout, 0, 0, &domain); mpp_get_compute_domain2d( domain, &isc, &iec, &jsc, &jec); nxc = iec - isc + 1; nyc = jec - jsc + 1; if(my_topog_type == DOME ) { x = (double *)malloc(nxc*nyc*sizeof(double)); y = (double *)malloc(nxc*nyc*sizeof(double)); } else { x = (double *)malloc((nxc+1)*(nyc+1)*sizeof(double)); y = (double *)malloc((nxc+1)*(nyc+1)*sizeof(double)); } depth = (double *)malloc(nxc*nyc*sizeof(double)); if(vgrid_file) num_levels = (int* )malloc(nxc*nyc*sizeof(int)); tmp = (double *)malloc((nxc*x_refine+1)*(nyc*y_refine+1)*sizeof(double)); start[0] = jsc*y_refine; start[1] = isc*x_refine; nread[0] = nyc*y_refine+1; nread[1] = nxc*x_refine+1; ni = nxc*x_refine+1; g_fid = mpp_open(tile_files[n], MPP_READ); vid = mpp_get_varid(g_fid, "x"); mpp_get_var_value_block(g_fid, vid, start, nread, tmp); if(my_topog_type == DOME ) { for(j = 0; j < nyc; j++) for(i = 0; i < nxc; i++) x[j*nxc+i] = tmp[(j*y_refine+1)*ni+i*x_refine+1]; } else { for(j = 0; j < nyc+1; j++) for(i = 0; i < nxc+1; i++) x[j*(nxc+1)+i] = tmp[(j*y_refine)*ni+i*x_refine]; } vid = mpp_get_varid(g_fid, "y"); mpp_get_var_value_block( g_fid, vid, start, nread, tmp); mpp_close(g_fid); if(my_topog_type == DOME ) { for(j = 0; j < nyc; j++) for(i = 0; i < nxc; i++) y[j*nxc+i] = tmp[(j*y_refine+1)*ni+i*x_refine+1]; } else { for(j = 0; j < nyc+1; j++) for(i = 0; i < nxc+1; i++) y[j*(nxc+1)+i] = tmp[(j*y_refine)*ni+i*x_refine]; } switch (my_topog_type) { case RECTANGULAR_BASIN: create_rectangular_topog(nx[n], ny[n], bottom_depth, depth); break; case GAUSSIAN: create_gaussian_topog(nx[n], ny[n], x, y, bottom_depth, min_depth, gauss_amp, gauss_scale, slope_x, slope_y, depth); break; case BOWL: create_bowl_topog(nx[n], ny[n], x, y, bottom_depth, min_depth, bowl_east, bowl_south, bowl_west, bowl_north, depth); break; case IDEALIZED: create_idealized_topog( nx[n], ny[n], x, y, bottom_depth, min_depth, depth); break; case REALISTIC: create_realistic_topog(nxc, nyc, x, y, vgrid_file, topog_file, topog_field, scale_factor, tripolar_grid, cyclic_x, cyclic_y, fill_first_row, filter_topog, num_filter_pass, smooth_topo_allow_deepening, round_shallow, fill_shallow, deepen_shallow, full_cell, flat_bottom, adjust_topo, fill_isolated_cells, dont_change_landmask, kmt_min, min_thickness, open_very_this_cell, fraction_full_cell, depth, num_levels, domain, verbose, use_great_circle_algorithm ); break; case BOX_CHANNEL: create_box_channel_topog(nx[n], ny[n], bottom_depth, jwest_south, jwest_north, jeast_south, jeast_north, depth); break; case DOME: create_dome_topog(nx[n], ny[n], x, y, dome_slope, dome_bottom, dome_embayment_west, dome_embayment_east, dome_embayment_south, dome_embayment_depth, depth); break; } gdata = (double *)malloc(nx[n]*ny[n]*sizeof(double)); mpp_global_field_double(domain, nxc, nyc, depth, gdata); mpp_put_var_value(fid, id_depth[n], gdata); if(vgrid_file) { double *tmp_double=NULL; int *gdata_int=NULL; tmp_double = (double *)malloc(nxc*nyc*sizeof(double)); gdata_int = (int *)malloc(nx[n]*ny[n]*sizeof(int)); for(i=0; i<nxc*nyc; i++) tmp_double[i] = num_levels[i]; mpp_global_field_double(domain, nxc, nyc, tmp_double, gdata); for(i=0; i<nx[n]*ny[n]; i++) gdata_int[i] = gdata[i]; mpp_put_var_value(fid, id_level[n], gdata_int); free(gdata_int); free(tmp_double); free(num_levels); } free(x); free(y); free(tmp); free(depth); free(gdata); mpp_delete_domain2d(&domain); } mpp_close(fid); /*release memory */ free(id_depth); free(id_level); for(n=0; n<ntiles; n++) free(tile_files[n]); free(tile_files); free(nx); free(ny); free(nxp); free(nyp); } if(mpp_pe() == mpp_root_pe() && verbose ) printf("Successfully generate %s\n",output_file); mpp_end(); return 0; }; //main
int main(int argc, char* argv[]) { int nratio = 1; int ndivx[] = {1,1,1,1,1,1}; int ndivy[] = {1,1,1,1,1,1}; char method[32] = "conformal"; char orientation[32] = "center_pole"; int nxbnds=2, nybnds=2, nxbnds0=0, nybnds0=0, nxbnds1=0, nybnds1=0, nxbnds2=0, nybnds2=0; double xbnds[MAXBOUNDS], ybnds[MAXBOUNDS]; int nlon[MAXBOUNDS-1], nlat[MAXBOUNDS-1]; char grid_type[128]="regular_lonlat_grid"; char my_grid_file[MAXBOUNDS][STRINGLEN]; double lat_join=65.; double simple_dx=0, simple_dy=0; int nx, ny, nxp, nyp, ntiles=1, ntilex=0, ntiley=0, ntiles_file; double *x=NULL, *y=NULL, *dx=NULL, *dy=NULL, *angle_dx=NULL, *angle_dy=NULL, *area=NULL; char history[2560]; char gridname[32] = "horizontal_grid"; char center[32] = "none"; char geometry[32] = "spherical"; char projection[32] = "none"; char arcx[32] = "small_circle"; char north_pole_tile[32] = "0.0 90.0"; char north_pole_arcx[32] = "0.0 90.0"; char discretization[32] = "logically_rectangular"; char conformal[32] = "true"; char mesg[256], str[128]; char entry[MAXBOUNDS*STRINGLEN]; int isc, iec, jsc, jec, nxc, nyc, layout[2]; domain2D domain; int n, errflg, c, i; int option_index; static struct option long_options[] = { {"grid_type", required_argument, NULL, 'a'}, {"my_grid_file", required_argument, NULL, 'b'}, {"nxbnds", required_argument, NULL, 'c'}, {"nybnds", required_argument, NULL, 'd'}, {"xbnds", required_argument, NULL, 'e'}, {"ybnds", required_argument, NULL, 'f'}, {"nlon", required_argument, NULL, 'g'}, {"nlat", required_argument, NULL, 'i'}, {"lat_join", required_argument, NULL, 'j'}, {"nratio", required_argument, NULL, 'k'}, {"simple_dx", required_argument, NULL, 'l'}, {"simple_dy", required_argument, NULL, 'm'}, {"ndivx", required_argument, NULL, 'o'}, {"ndivy", required_argument, NULL, 'p'}, {"grid_name", required_argument, NULL, 'q'}, {"center", required_argument, NULL, 'r'}, {"help", no_argument, NULL, 'h'}, {0, 0, 0, 0}, }; /* start parallel */ mpp_init(&argc, &argv); mpp_domain_init(); /* * process command line */ errflg = argc <3; while ((c = getopt_long(argc, argv, "", long_options, &option_index)) != -1) { switch (c) { case 'a': strcpy(grid_type, optarg); break; case 'b': strcpy(entry, optarg); tokenize(entry, ",", STRINGLEN, MAXBOUNDS, my_grid_file, &ntiles_file); break; case 'c': nxbnds0 = atoi(optarg); break; case 'd': nybnds0 = atoi(optarg); break; case 'e': strcpy(entry, optarg); nxbnds1 = get_double_entry(entry, xbnds); break; case 'f': strcpy(entry, optarg); nybnds1 = get_double_entry(entry, ybnds); break; case 'g': strcpy(entry, optarg); nxbnds2 = get_int_entry(entry, nlon); break; case 'i': strcpy(entry, optarg); nybnds2 = get_int_entry(entry, nlat); break; case 'j': lat_join = atof(optarg); break; case 'k': nratio = atoi(optarg); break; case 'l': simple_dx = atof(optarg); break; case 'm': simple_dy = atof(optarg); break; case 'o': strcpy(entry, optarg); ntilex = get_int_entry(entry, ndivx); break; case 'p': strcpy(entry, optarg); ntiley = get_int_entry(entry, ndivy); break; case 'q': strcpy(gridname, optarg); break; case 'r': strcpy(center, optarg); break; case 'h': errflg++; break; case '?': errflg++; } } if (errflg ) { char **u = usage; while (*u) { fprintf(stderr, "%s\n", *u); u++; } exit(2); } /* define history to be the history in the grid file */ strcpy(history,argv[0]); for(i=1;i<argc;i++) { strcat(history, " "); strcat(history, argv[i]); } if(mpp_pe() == mpp_root_pe() ) printf("==>NOTE: the grid type is %s\n",grid_type); /* check the command-line arguments to make sure the value are suitable */ if( strcmp(grid_type,"regular_lonlat_grid") ==0 ) { nxbnds = nxbnds0; nybnds = nybnds0; if( nxbnds <2 || nybnds < 2) mpp_error("make_hgrid: grid type is 'regular_lonlat_grid', " "both nxbnds and nybnds should be no less than 2"); if( nxbnds != nxbnds1 || nxbnds != nxbnds2+1 ) mpp_error("make_hgrid: grid type is 'regular_lonlat_grid', nxbnds does" "not match number of entry in xbnds or nlon"); if( nybnds != nybnds1 || nybnds != nybnds2+1 ) mpp_error("make_hgrid: grid type is 'regular_lonlat_grid', nybnds does " "not match number of entry in ybnds or nlat"); } else if( strcmp(grid_type,"tripolar_grid") ==0 ) { strcpy(projection, "tripolar"); nxbnds = nxbnds0; nybnds = nybnds0; if( nxbnds != 2) mpp_error("make_hgrid: grid type is 'tripolar_grid', nxbnds should be 2"); if( nybnds < 2) mpp_error("make_hgrid: grid type is 'tripolar_grid', nybnds should be no less than 2"); if( nxbnds != nxbnds1 || nxbnds != nxbnds2+1 ) mpp_error("make_hgrid: grid type is 'tripolar_grid', nxbnds does not match number of entry in xbnds or nlon"); if( nybnds != nybnds1 || nybnds != nybnds2+1 ) mpp_error("make_hgrid: grid type is 'tripolar_grid', nybnds does not match number of entry in ybnds or nlat"); } else if( strcmp(grid_type,"from_file") ==0 ) { /* For ascii file, nlon and nlat should be specified through --nlon, --nlat For netcdf file, grid resolution will be read from grid file */ if(ntiles_file == 0) mpp_error("make_hgrid: grid_type is 'from_file', but my_grid_file is not specified"); ntiles = ntiles_file; for(n=0; n<ntiles; n++) { if(strstr(my_grid_file[n],".nc") ) { /* get the grid size for each tile, the grid is on model grid, should need to multiply by 2 */ int fid; fid = mpp_open(my_grid_file[n], MPP_READ); nlon[n] = mpp_get_dimlen(fid, "grid_xt")*2; nlat[n] = mpp_get_dimlen(fid, "grid_yt")*2; mpp_close(fid); } else { if(nxbnds2 != ntiles || nybnds2 != ntiles ) mpp_error("make_hgrid: grid type is 'from_file', number entry entered " "through --nlon and --nlat should be equal to number of files " "specified through --my_grid_file"); } } /* for simplify purpose, currently we assume all the tile have the same grid size */ for(n=1; n<ntiles; n++) { if( nlon[n] != nlon[0] || nlat[n] != nlat[0]) mpp_error("make_hgrid: grid_type is from_file, all the tiles should " "have same grid size, contact developer"); } } else if( strcmp(grid_type,"simple_cartesian_grid") ==0) { strcpy(geometry, "planar"); strcpy(north_pole_tile, "none"); if(nxbnds1 != 2 || nybnds1 != 2 ) mpp_error("make_hgrid: grid type is 'simple_cartesian_grid', number entry entered " "through --xbnds and --ybnds should be 2"); if(nxbnds2 != 1 || nybnds2 != 1 ) mpp_error("make_hgrid: grid type is 'simple_cartesian_grid', number entry entered " "through --nlon and --nlat should be 1"); if(simple_dx == 0 || simple_dy == 0) mpp_error("make_hgrid: grid_type is 'simple_cartesian_grid', " "both simple_dx and simple_dy both should be specified"); } else if ( strcmp(grid_type,"spectral_grid") ==0 ) { if(nxbnds2 != 1 || nybnds2 != 1 ) mpp_error("make_hgrid: grid type is 'spectral_grid', number entry entered " "through --nlon and --nlat should be 1"); } else if( strcmp(grid_type,"conformal_cubic_grid") ==0 ) { strcpy(projection, "cube_gnomonic"); strcpy(conformal, "FALSE"); if(nxbnds2 != 1 ) mpp_error("make_hgrid: grid type is 'conformal_cubic_grid', number entry entered " "through --nlon should be 1"); if(nratio < 1) mpp_error("make_hgrid: grid type is 'conformal_cubic_grid', nratio should be a positive integer"); } else if( !strcmp(grid_type,"gnomonic_ed") ) { strcpy(projection, "cube_gnomonic"); strcpy(conformal, "FALSE"); if(nxbnds2 != 1 ) mpp_error("make_hgrid: grid type is 'gnomonic_cubic_grid', number entry entered " "through --nlon should be 1"); } else { mpp_error("make_hgrid: only grid_type = 'regular_lonlat_grid', 'tripolar_grid', 'from_file', " "'gnomonic_ed', 'conformal_cubic_grid', 'simple_cartesian_grid' and " "'spectral_grid' is implemented"); } /* get super grid size */ if( !strcmp(grid_type,"gnomonic_ed") || !strcmp(grid_type,"conformal_cubic_grid") ) { nx = nlon[0]; ny = nx; } else { nx = 0; ny = 0; for(n=0; n<nxbnds-1; n++) nx += nlon[n]; for(n=0; n<nybnds-1; n++) ny += nlat[n]; } nxp = nx + 1; nyp = ny + 1; if( !strcmp(grid_type,"gnomonic_ed") || !strcmp(grid_type,"conformal_cubic_grid") ) { ntiles = 6; /* Cubic grid is required to run on single processor.*/ if(mpp_npes() > 1) mpp_error( "make_hgrid: cubic grid generation must be run one processor, contact developer"); } /* Currently we restrict nx can be divided by ndivx and ny can be divided by ndivy */ if(ntilex >0 && ntilex != ntiles) mpp_error("make_hgrid: number of entry specified through --ndivx does not equal ntiles"); if(ntiley >0 && ntiley != ntiles) mpp_error("make_hgrid: number of entry specified through --ndivy does not equal ntiles"); for(n=0; n<ntiles; n++) { if( nx%ndivx[n] ) mpp_error("make_hgrid: nx can not be divided by ndivx"); if( ny%ndivy[n] ) mpp_error("make_hgrid: ny can not be divided by ndivy"); } if(strcmp(center,"none") && strcmp(center,"c_cell") && strcmp(center,"t_cell") ) mpp_error("make_hgrid: center should be 'none', 'c_cell' or 't_cell' "); /* set up domain decomposition, x and y will be on global domain and other fields will be on compute domain. */ mpp_define_layout( nx, ny, mpp_npes(), layout); mpp_define_domain2d( nx, ny, layout, 0, 0, &domain); mpp_get_compute_domain2d(domain, &isc, &iec, &jsc, &jec); nxc = iec - isc + 1; nyc = jec - jsc + 1; /* create grid information */ x = (double *) malloc(nxp*nyp*ntiles*sizeof(double)); y = (double *) malloc(nxp*nyp*ntiles*sizeof(double)); dx = (double *) malloc(nxc*(nyc+1)*ntiles*sizeof(double)); dy = (double *) malloc((nxc+1)*nyc*ntiles*sizeof(double)); area = (double *) malloc(nxc *nyc*ntiles*sizeof(double)); angle_dx = (double *) malloc((nxc+1)*(nyc+1)*ntiles*sizeof(double)); if( strcmp(conformal,"true") !=0 )angle_dy = (double *) malloc(nxp*nyp*ntiles*sizeof(double)); if(strcmp(grid_type,"regular_lonlat_grid") ==0) create_regular_lonlat_grid(&nxbnds, &nybnds, xbnds, ybnds, nlon, nlat, &isc, &iec, &jsc, &jec, x, y, dx, dy, area, angle_dx, center); else if(strcmp(grid_type,"tripolar_grid") ==0) create_tripolar_grid(&nxbnds, &nybnds, xbnds, ybnds, nlon, nlat, &lat_join, &isc, &iec, &jsc, &jec, x, y, dx, dy, area, angle_dx, center); else if( strcmp(grid_type,"from_file") ==0 ) { for(n=0; n<ntiles; n++) { int n1, n2, n3, n4; n1 = n * nxp * nyp; n2 = n * nx * nyp; n3 = n * nxp * ny; n4 = n * nx * ny; create_grid_from_file(my_grid_file[n], &nx, &ny, x+n1, y+n1, dx+n2, dy+n3, area+n4, angle_dx+n1); } } else if(strcmp(grid_type,"simple_cartesian_grid") ==0) create_simple_cartesian_grid(xbnds, ybnds, &nx, &ny, &simple_dx, &simple_dy, &isc, &iec, &jsc, &jec, x, y, dx, dy, area, angle_dx ); else if(strcmp(grid_type,"spectral_grid") ==0 ) create_spectral_grid(&nx, &ny, &isc, &iec, &jsc, &jec, x, y, dx, dy, area, angle_dx ); else if(strcmp(grid_type,"conformal_cubic_grid") ==0 ) create_conformal_cubic_grid(&nx, &nratio, method, orientation, x, y, dx, dy, area, angle_dx, angle_dy ); else if(strcmp(grid_type,"gnomonic_ed") ==0 ) create_gnomonic_cubic_grid(grid_type, &nx, x, y, dx, dy, area, angle_dx, angle_dy ); /* write out data */ { int fid, id_tile, id_x, id_y, id_dx, id_dy, id_area, id_angle_dx, id_angle_dy, id_arcx; int dimlist[5], dims[2], i, j, l, ni, nj, nip, njp, m; size_t start[4], nwrite[4]; double *tmp, *gdata; char tilename[128] = ""; char outfile[128] = ""; l = 0; for(n=0 ; n< ntiles; n++) { for(j=0; j<ndivy[n]; j++) { for(i=0; i<ndivx[n]; i++) { ++l; sprintf(tilename, "tile%d", l); if(ntiles>1) sprintf(outfile, "%s.tile%d.nc", gridname, l); else sprintf(outfile, "%s.nc", gridname); fid = mpp_open(outfile, MPP_WRITE); /* define dimenison */ ni = nx/ndivx[n]; nj = ny/ndivy[n]; nip = ni + 1; njp = nj + 1; dimlist[0] = mpp_def_dim(fid, "string", STRINGLEN); dimlist[1] = mpp_def_dim(fid, "nx", ni); dimlist[2] = mpp_def_dim(fid, "ny", nj); dimlist[3] = mpp_def_dim(fid, "nxp", nip); dimlist[4] = mpp_def_dim(fid, "nyp", njp); /* define variable */ if( strcmp(north_pole_tile, "none") == 0) /* no north pole, then no projection */ id_tile = mpp_def_var(fid, "tile", MPP_CHAR, 1, dimlist, 4, "standard_name", "grid_tile_spec", "geometry", geometry, "discretization", discretization, "conformal", conformal ); else if( strcmp(projection, "none") == 0) id_tile = mpp_def_var(fid, "tile", MPP_CHAR, 1, dimlist, 5, "standard_name", "grid_tile_spec", "geometry", geometry, "north_pole", north_pole_tile, "discretization", discretization, "conformal", conformal ); else id_tile = mpp_def_var(fid, "tile", MPP_CHAR, 1, dimlist, 6, "standard_name", "grid_tile_spec", "geometry", geometry, "north_pole", north_pole_tile, "projection", projection, "discretization", discretization, "conformal", conformal ); dims[0] = dimlist[4]; dims[1] = dimlist[3]; id_x = mpp_def_var(fid, "x", MPP_DOUBLE, 2, dims, 2, "standard_name", "geographic_longitude", "units", "degree_east"); id_y = mpp_def_var(fid, "y", MPP_DOUBLE, 2, dims, 2, "standard_name", "geographic_latitude", "units", "degree_north"); dims[0] = dimlist[4]; dims[1] = dimlist[1]; id_dx = mpp_def_var(fid, "dx", MPP_DOUBLE, 2, dims, 2, "standard_name", "grid_edge_x_distance", "units", "meters"); dims[0] = dimlist[2]; dims[1] = dimlist[3]; id_dy = mpp_def_var(fid, "dy", MPP_DOUBLE, 2, dims, 2, "standard_name", "grid_edge_y_distance", "units", "meters"); dims[0] = dimlist[2]; dims[1] = dimlist[1]; id_area = mpp_def_var(fid, "area", MPP_DOUBLE, 2, dims, 2, "standard_name", "grid_cell_area", "units", "m2" ); dims[0] = dimlist[4]; dims[1] = dimlist[3]; id_angle_dx = mpp_def_var(fid, "angle_dx", MPP_DOUBLE, 2, dims, 2, "standard_name", "grid_vertex_x_angle_WRT_geographic_east", "units", "degrees_east"); if(strcmp(conformal, "true") != 0) id_angle_dy = mpp_def_var(fid, "angle_dy", MPP_DOUBLE, 2, dims, 2, "standard_name", "grid_vertex_y_angle_WRT_geographic_north", "units", "degrees_north"); if( strcmp(north_pole_arcx, "none") == 0) id_arcx = mpp_def_var(fid, "arcx", MPP_CHAR, 1, dimlist, 1, "standard_name", "grid_edge_x_arc_type" ); else id_arcx = mpp_def_var(fid, "arcx", MPP_CHAR, 1, dimlist, 2, "standard_name", "grid_edge_x_arc_type", "north_pole", north_pole_arcx ); mpp_def_global_att(fid, "grid_version", grid_version); mpp_def_global_att(fid, "code_version", tagname); mpp_def_global_att(fid, "history", history); mpp_end_def(fid); for(m=0; m<4; m++) { start[m] = 0; nwrite[m] = 0; } nwrite[0] = strlen(tilename); mpp_put_var_value_block(fid, id_tile, start, nwrite, tilename ); tmp = get_subregion(nxp, x+n*nxp*nyp, i*ni, (i+1)*ni, j*nj, (j+1)*nj); mpp_put_var_value(fid, id_x, tmp); free(tmp); tmp = get_subregion(nxp, y+n*nxp*nyp, i*ni, (i+1)*ni, j*nj, (j+1)*nj); mpp_put_var_value(fid, id_y, tmp); free(tmp); gdata = (double *)malloc(nx*nyp*sizeof(double)); mpp_global_field_double(domain, nxc, nyc+1, dx+n*nx*nyp, gdata); tmp = get_subregion( nx, gdata, i*ni, (i+1)*ni-1, j*nj, (j+1)*nj); mpp_put_var_value(fid, id_dx, tmp); free(tmp); free(gdata); gdata = (double *)malloc(nxp*ny*sizeof(double)); mpp_global_field_double(domain, nxc+1, nyc, dy+n*nxp*ny, gdata); tmp = get_subregion( nxp, gdata, i*ni, (i+1)*ni, j*nj, (j+1)*nj-1); mpp_put_var_value(fid, id_dy, tmp); free(tmp); free(gdata); gdata = (double *)malloc(nx*ny*sizeof(double)); mpp_global_field_double(domain, nxc, nyc, area+n*nx*ny, gdata); tmp = get_subregion( nx, gdata, i*ni, (i+1)*ni-1, j*nj, (j+1)*nj-1); mpp_put_var_value(fid, id_area, tmp); free(tmp); free(gdata); gdata = (double *)malloc(nxp*nyp*sizeof(double)); mpp_global_field_double(domain, nxc+1, nyc+1, angle_dx+n*nxp*nyp, gdata); tmp = get_subregion( nxp, gdata, i*ni, (i+1)*ni, j*nj, (j+1)*nj); mpp_put_var_value(fid, id_angle_dx, tmp); free(tmp); free(gdata); if(strcmp(conformal, "true") != 0) { gdata = (double *)malloc(nxp*nyp*sizeof(double)); mpp_global_field_double(domain, nxc+1, nyc+1, angle_dy+n*nxp*nyp, gdata); tmp = get_subregion( nxp, gdata, i*ni, (i+1)*ni, j*nj, (j+1)*nj); mpp_put_var_value(fid, id_angle_dy, tmp); free(tmp); free(gdata); } nwrite[0] = strlen(arcx); mpp_put_var_value_block(fid, id_arcx, start, nwrite, arcx ); mpp_close(fid); } } } } free(x); free(y); free(dx); free(dy); free(area); free(angle_dx); if(strcmp(conformal, "true") != 0) free(angle_dy); if(mpp_pe() == mpp_root_pe()) printf("generate_grid is run successfully. \n"); mpp_end(); return 0; }; /* end of main */