main (int argc, char *argv[]) { extern char *optarg; char *pch=NULL, *dir=NULL, history[512], entry[1280]; char tilefile[MAXTILE][STRING], tiletype[MAXTILE][SHORTSTRING]; char tile_name[MAXTILE][STRING]; int ntiles=0, nfiles=0, ncontact=0; int *nxp, *nyp; double **x, **y; double periodx=0, periody=0; int contact_tile1[MAXCONTACT], contact_tile2[MAXCONTACT]; int contact_tile1_istart[MAXCONTACT], contact_tile1_iend[MAXCONTACT]; int contact_tile1_jstart[MAXCONTACT], contact_tile1_jend[MAXCONTACT]; int contact_tile2_istart[MAXCONTACT], contact_tile2_iend[MAXCONTACT]; int contact_tile2_jstart[MAXCONTACT], contact_tile2_jend[MAXCONTACT]; char mosaic_name[128] = "solo_mosaic"; char grid_descriptor[128] = ""; int c, i, n, m, l, errflg; int option_index = 0; static struct option long_options[] = { {"mosaic_name", required_argument, NULL, 'm'}, {"num_tiles", required_argument, NULL, 'n'}, {"grid_descriptor", required_argument, NULL, 'g'}, {"tile_file", required_argument, NULL, 'f'}, {"periodx", required_argument, NULL, 'x'}, {"periody", required_argument, NULL, 'y'}, {"directory", required_argument, NULL, 'd'}, {NULL, 0, NULL, 0} }; mpp_init(&argc, &argv); /* this tool must be run one processor */ if(mpp_npes()>1) mpp_error("make_solo_mosaic: this tool must be run on one processor"); errflg = (argc == 1); /* First read command line arguments. */ while ((c = getopt_long(argc, argv, "h", long_options, &option_index)) != -1) { switch (c) { case 'n': ntiles = atoi(optarg); break; case 'm': strcpy(mosaic_name, optarg); break; case 'g': strcpy(grid_descriptor, optarg); break; case 'f': strcpy(entry, optarg); pch = strtok(entry, ", "); nfiles = 0; while( pch != NULL) { strcpy(tilefile[nfiles++], pch); pch = strtok(NULL, ", "); } break; case 'x': periodx = atof(optarg); break; case 'y': periody = atof(optarg); break; case 'd': // path of the simple grid file. dir = optarg; break; case '?': errflg++; } } if (errflg || ntiles < 1 || !dir ) { char **u = usage; while (*u) { fprintf(stderr, "%s\n", *u); u++; } exit(2); } strcpy(history,argv[0]); for(i=1;i<argc;i++) { strcat(history, " "); strcat(history, argv[i]); } if(ntiles > MAXTILE) { mpp_error("make_solo_mosaic: number of tiles is greater than MAXTILE."); } /*--- if file name is not specified through -f, file name will be horizontal_grid.tile#.nc */ if(nfiles == 0) { if(ntiles == 1) { sprintf(tilefile[0],"horizontal_grid.nc"); } else { for(n=0; n<ntiles; n++) { sprintf(tilefile[n],"horizontal_grid.tile%d.nc",n+1); } } } else { /* Check if ntile are matching number of grid file passed through -f */ if( nfiles != ntiles) mpp_error("make_solo_mosaic: number of grid files specified through -n " " does not equal to number of files specified through -f = "); } n = strlen(dir); if( dir[n-1] != '/') strcat(dir, "/"); /*First read all the grid files.*/ nxp = (int *)malloc(ntiles*sizeof(int)); nyp = (int *)malloc(ntiles*sizeof(int)); x = (double **)malloc(ntiles*sizeof(double *)); y = (double **)malloc(ntiles*sizeof(double *)); for(n=0; n<ntiles; n++) { char filepath[512]; int fid, vid; sprintf(filepath, "%s%s",dir, tilefile[n]); fid = mpp_open(filepath, MPP_READ); nxp[n] = mpp_get_dimlen(fid, "nxp"); nyp[n] = mpp_get_dimlen(fid, "nyp"); x[n] = (double *)malloc(nxp[n]*nyp[n]*sizeof(double)); y[n] = (double *)malloc(nxp[n]*nyp[n]*sizeof(double)); vid = mpp_get_varid(fid, "tile"); mpp_get_var_value(fid, vid, tile_name[n]); vid = mpp_get_varid(fid, "x"); mpp_get_var_value(fid, vid, x[n]); vid = mpp_get_varid(fid, "y"); mpp_get_var_value(fid, vid, y[n]); mpp_close(fid); } /*find the contact region between tiles, currently assume the contact region are align-contact There should be no contact between same directions of two tiles ( w-w, e-e, s-s, n-n) We assume no contact between w-s, e-n ( will added in if needed ) . */ ncontact = 0; for(n=0; n<ntiles; n++) { for(m=n; m<ntiles; m++) { int count; int istart1[MAXCONTACT], iend1[MAXCONTACT], jstart1[MAXCONTACT], jend1[MAXCONTACT]; int istart2[MAXCONTACT], iend2[MAXCONTACT], jstart2[MAXCONTACT], jend2[MAXCONTACT]; count = get_align_contact(n+1, m+1, nxp[n], nyp[n], nxp[m], nyp[m], x[n], y[n], x[m], y[m], periodx, periody, istart1, iend1, jstart1, jend1, istart2, iend2, jstart2, jend2); if(ncontact+count>MAXCONTACT) mpp_error("make_solo_mosaic: number of contacts is more than MAXCONTACT 1"); for(l=0; l<count; l++) { contact_tile1_istart[ncontact] = istart1[l]; contact_tile1_iend [ncontact] = iend1[l]; contact_tile1_jstart[ncontact] = jstart1[l]; contact_tile1_jend [ncontact] = jend1[l]; contact_tile2_istart[ncontact] = istart2[l]; contact_tile2_iend [ncontact] = iend2[l]; contact_tile2_jstart[ncontact] = jstart2[l]; contact_tile2_jend [ncontact] = jend2[l]; contact_tile1 [ncontact] = n; contact_tile2 [ncontact] = m; ncontact++; } } } for(n=0; n<ntiles; n++) { for(m=n+1; m<ntiles; m++) { int count; int istart1[MAXCONTACT], iend1[MAXCONTACT], jstart1[MAXCONTACT], jend1[MAXCONTACT]; int istart2[MAXCONTACT], iend2[MAXCONTACT], jstart2[MAXCONTACT], jend2[MAXCONTACT]; count = get_overlap_contact(n+1, m+1, nxp[n], nyp[n], nxp[m], nyp[m], x[n], y[n], x[m], y[m], istart1, iend1, jstart1, jend1, istart2, iend2, jstart2, jend2); if(ncontact+count>MAXCONTACT) mpp_error("make_solo_mosaic: number of contacts is more than MAXCONTACT 2"); for(l=0; l<count; l++) { contact_tile1_istart[ncontact] = istart1[l]; contact_tile1_iend [ncontact] = iend1[l]; contact_tile1_jstart[ncontact] = jstart1[l]; contact_tile1_jend [ncontact] = jend1[l]; contact_tile2_istart[ncontact] = istart2[l]; contact_tile2_iend [ncontact] = iend2[l]; contact_tile2_jstart[ncontact] = jstart2[l]; contact_tile2_jend [ncontact] = jend2[l]; contact_tile1 [ncontact] = n; contact_tile2 [ncontact] = m; ncontact++; } } } /* write out data */ { char str[STRING], outfile[STRING]; int fid, dim_ntiles, dim_ncontact, dim_string, id_mosaic, id_gridtiles, id_contacts; int id_contact_index, id_griddir, id_gridfiles, dim[2]; size_t start[4], nwrite[4]; sprintf(outfile, "%s.nc", mosaic_name); fid = mpp_open(outfile, MPP_WRITE); /* define dimenison */ dim_ntiles = mpp_def_dim(fid, "ntiles", ntiles); if(ncontact>0) dim_ncontact = mpp_def_dim(fid, "ncontact", ncontact); dim_string = mpp_def_dim(fid, "string", STRING); /* define variable */ id_mosaic = mpp_def_var(fid, "mosaic", MPP_CHAR, 1, &dim_string, 4, "standard_name", "grid_mosaic_spec", "children", "gridtiles", "contact_regions", "contacts", "grid_descriptor", grid_descriptor); dim[0] = dim_ntiles; dim[1] = dim_string; id_griddir = mpp_def_var(fid, "gridlocation", MPP_CHAR, 1, &dim[1], 1, "standard_name", "grid_file_location"); id_gridfiles = mpp_def_var(fid, "gridfiles", MPP_CHAR, 2, dim, 0); id_gridtiles = mpp_def_var(fid, "gridtiles", MPP_CHAR, 2, dim, 0); if(ncontact>0) { dim[0] = dim_ncontact; dim[1] = dim_string; id_contacts = mpp_def_var(fid, "contacts", MPP_CHAR, 2, dim, 5, "standard_name", "grid_contact_spec", "contact_type", "boundary", "alignment", "true", "contact_index", "contact_index", "orientation", "orient"); id_contact_index = mpp_def_var(fid, "contact_index", MPP_CHAR, 2, dim, 1, "standard_name", "starting_ending_point_index_of_contact"); } 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); /* write out data */ for(i=0; i<4; i++) { start[i] = 0; nwrite[i] = 1; } nwrite[0] = strlen(mosaic_name); mpp_put_var_value_block(fid, id_mosaic, start, nwrite, mosaic_name); nwrite[0] = strlen(dir); mpp_put_var_value_block(fid, id_griddir, start, nwrite, dir); nwrite[0] = 1; for(n=0; n<ntiles; n++) { start[0] = n; nwrite[1] = strlen(tile_name[n]); mpp_put_var_value_block(fid, id_gridtiles, start, nwrite, tile_name[n]); nwrite[1] = strlen(tilefile[n]); mpp_put_var_value_block(fid, id_gridfiles, start, nwrite, tilefile[n]); } for(n=0; n<ncontact; n++) { sprintf(str,"%s:%s::%s:%s", mosaic_name, tile_name[contact_tile1[n]], mosaic_name, tile_name[contact_tile2[n]]); start[0] = n; nwrite[1] = strlen(str); mpp_put_var_value_block(fid, id_contacts, start, nwrite, str); sprintf(str,"%d:%d,%d:%d::%d:%d,%d:%d", contact_tile1_istart[n], contact_tile1_iend[n], contact_tile1_jstart[n], contact_tile1_jend[n], contact_tile2_istart[n], contact_tile2_iend[n], contact_tile2_jstart[n], contact_tile2_jend[n] ); nwrite[1] = strlen(str); mpp_put_var_value_block(fid, id_contact_index, start, nwrite, str); } mpp_close(fid); } printf("congradulation: You have successfully run make_solo_mosaic\n"); return 0; }; // end of main
int main (int argc, char *argv[]) { int c, n, i; int errflg = (argc == 1); int option_index = 0; int fid, vid, nfile_aXl, ntiles; int *nx, *ny; double **lonb, **latb, **land_area, **ocean_area, **cell_area; char **axl_file = NULL, **axo_file=NULL, **lxo_file=NULL; char **ocn_topog_file = NULL; char *input_mosaic = NULL; char mosaic_name[STRING] = "mosaic", mosaic_file[STRING]; char griddir[STRING], lnd_mosaic[STRING], filepath[STRING]; char history[512]; static struct option long_options[] = { {"input_mosaic", required_argument, NULL, 'i'}, {"mosaic_name", required_argument, NULL, 'm'}, {NULL, 0, NULL, 0} }; /* * process command line */ while ((c = getopt_long(argc, argv, "i:", long_options, &option_index) ) != -1) switch (c) { case 'i': input_mosaic = optarg; break; case 'm': strcpy(mosaic_name,optarg); break; case '?': errflg++; } if (errflg || !input_mosaic) { char **u = usage; while (*u) { fprintf(stderr, "%s\n", *u); u++; } exit(2); } strcpy(history,argv[0]); for(i=1;i<argc;i++) { strcat(history, " "); strcat(history, argv[i]); } /* First get land grid information */ mpp_init(&argc, &argv); sprintf(mosaic_file, "%s.nc", mosaic_name); get_file_path(input_mosaic, griddir); fid = mpp_open(input_mosaic, MPP_READ); vid = mpp_get_varid(fid, "lnd_mosaic_file"); mpp_get_var_value(fid, vid, lnd_mosaic); nfile_aXl = mpp_get_dimlen( fid, "nfile_aXl"); /*make sure the directory that stores the mosaic_file is not current directory */ { char cur_path[STRING]; if(getcwd(cur_path, STRING) != cur_path ) mpp_error("make_quick_mosaic: The size of cur_path maybe is not big enough"); printf("The current directory is %s\n", cur_path); printf("The mosaic file location is %s\n", griddir); if(strcmp(griddir, cur_path)==0 || strcmp( griddir, ".")==0) mpp_error("make_quick_mosaic: The input mosaic file location should not be current directory"); } sprintf(filepath, "%s/%s", griddir, lnd_mosaic); ntiles = read_mosaic_ntiles(filepath); /* copy the lnd_mosaic file and grid file */ { int fid2, vid2; char cmd[STRING], gridfile[STRING]; size_t start[4], nread[4]; sprintf(cmd, "cp %s %s", filepath, lnd_mosaic); system(cmd); fid2 = mpp_open(filepath, MPP_READ); vid2 = mpp_get_varid(fid2, "gridfiles"); for(i=0; i<4; i++) { start[i] = 0; nread[i] = 1; } for(n=0; n<ntiles; n++) { start[0] = n; nread[1] = STRING; mpp_get_var_value_block(fid2, vid2, start, nread, gridfile); sprintf(cmd, "cp %s/%s %s", griddir, gridfile, gridfile); printf("%s \n", cmd); system(cmd); } mpp_close(fid2); } /* ntiles should be either 1 or ntiles = nfile_aXl */ if(ntiles != nfile_aXl && ntiles != 1) mpp_error("make_quick_mosaic: only support ntiles = 1 or ntiles = nfile_aXl, contact developer"); nx = (int *)malloc(ntiles*sizeof(int)); ny = (int *)malloc(ntiles*sizeof(int)); read_mosaic_grid_sizes(filepath, nx, ny); lonb = (double **)malloc(ntiles*sizeof(double *)); latb = (double **)malloc(ntiles*sizeof(double *)); for(n=0; n<ntiles; n++) { lonb[n] = (double *)malloc((nx[n]+1)*(ny[n]+1)*sizeof(double)); latb[n] = (double *)malloc((nx[n]+1)*(ny[n]+1)*sizeof(double)); read_mosaic_grid_data(filepath, "x", nx[n], ny[n], lonb[n], n, 0, 0); read_mosaic_grid_data(filepath, "y", nx[n], ny[n], latb[n], n, 0, 0); for(i=0; i<(nx[n]+1)*(ny[n]+1); i++) { lonb[n][i] *= (M_PI/180.0); latb[n][i] *= (M_PI/180.0); } } /* read the exchange grid information and get the land/sea mask of land model*/ land_area = (double **)malloc(ntiles*sizeof(double *)); for(n=0; n<ntiles; n++) { land_area[n] = (double *)malloc(nx[n]*ny[n]*sizeof(double)); for(i=0; i<nx[n]*ny[n]; i++) land_area[n][i] = 0; } vid = mpp_get_varid(fid, "aXl_file"); for(n=0; n<nfile_aXl; n++) { size_t start[4], nread[4]; int nxgrid; char aXl_file[STRING]; start[0] = n; start[1] = 0; nread[0] = 1; nread[1] = STRING; mpp_get_var_value_block(fid, vid, start, nread, aXl_file); sprintf(filepath, "%s/%s", griddir, aXl_file); nxgrid = read_mosaic_xgrid_size(filepath); if(nxgrid>0) { int l; int *i1, *j1, *i2, *j2; double *area; i1 = (int *)malloc(nxgrid*sizeof(int)); j1 = (int *)malloc(nxgrid*sizeof(int)); i2 = (int *)malloc(nxgrid*sizeof(int)); j2 = (int *)malloc(nxgrid*sizeof(int)); area = (double *)malloc(nxgrid*sizeof(double)); read_mosaic_xgrid_order1(filepath, i1, j1, i2, j2, area); if(ntiles == 1) { for(l=0; l<nxgrid; l++) land_area[0][j2[l]*nx[0]+i2[l]] += (area[l]*4*M_PI*RADIUS*RADIUS); } else { for(l=0; l<nxgrid; l++) land_area[n][j2[l]*nx[n]+i2[l]] += (area[l]*4*M_PI*RADIUS*RADIUS); } free(i1); free(j1); free(i2); free(j2); free(area); } } mpp_close(fid); /* calculate ocean area */ ocean_area = (double **)malloc(ntiles*sizeof(double *)); cell_area = (double **)malloc(ntiles*sizeof(double *)); for(n=0; n<ntiles; n++) { ocean_area[n] = (double *)malloc(nx[n]*ny[n]*sizeof(double)); cell_area[n] = (double *)malloc(nx[n]*ny[n]*sizeof(double)); get_grid_area(&nx[n], &ny[n], lonb[n], latb[n], cell_area[n]); for(i=0; i<nx[n]*ny[n]; i++) { ocean_area[n][i] = cell_area[n][i]; if( fabs(ocean_area[n][i]-land_area[n][i])/ocean_area[n][i] < AREA_RATIO_THRESH ) ocean_area[n][i] = 0; else ocean_area[n][i] -= land_area[n][i]; if(ocean_area[n][i] < 0) { printf("at i = %d, ocean_area = %g, land_area = %g, cell_area=%g\n", i, ocean_area[n][i], land_area[n][i], cell_area[n][i]); mpp_error("make_quick_mosaic: ocean area is negative at some points"); } } } /* write out land mask */ { for(n=0; n<ntiles; n++) { int fid, id_mask, dims[2]; char lnd_mask_file[STRING]; double *mask; mask = (double *)malloc(nx[n]*ny[n]*sizeof(double)); for(i=0; i<nx[n]*ny[n]; i++) mask[i] = land_area[n][i]/cell_area[n][i]; if(ntiles > 1) sprintf(lnd_mask_file, "land_mask_tile%d.nc", n+1); else strcpy(lnd_mask_file, "land_mask.nc"); fid = mpp_open(lnd_mask_file, MPP_WRITE); mpp_def_global_att(fid, "grid_version", grid_version); mpp_def_global_att(fid, "code_version", tagname); mpp_def_global_att(fid, "history", history); dims[1] = mpp_def_dim(fid, "nx", nx[n]); dims[0] = mpp_def_dim(fid, "ny", ny[n]); id_mask = mpp_def_var(fid, "mask", MPP_DOUBLE, 2, dims, 2, "standard_name", "land fraction at T-cell centers", "units", "none"); mpp_end_def(fid); mpp_put_var_value(fid, id_mask, mask); free(mask); mpp_close(fid); } } /* write out ocean mask */ { for(n=0; n<ntiles; n++) { int fid, id_mask, dims[2]; char ocn_mask_file[STRING]; double *mask; mask = (double *)malloc(nx[n]*ny[n]*sizeof(double)); for(i=0; i<nx[n]*ny[n]; i++) mask[i] = ocean_area[n][i]/cell_area[n][i]; if(ntiles > 1) sprintf(ocn_mask_file, "ocean_mask_tile%d.nc", n+1); else strcpy(ocn_mask_file, "ocean_mask.nc"); fid = mpp_open(ocn_mask_file, MPP_WRITE); mpp_def_global_att(fid, "grid_version", grid_version); mpp_def_global_att(fid, "code_version", tagname); mpp_def_global_att(fid, "history", history); dims[1] = mpp_def_dim(fid, "nx", nx[n]); dims[0] = mpp_def_dim(fid, "ny", ny[n]); id_mask = mpp_def_var(fid, "mask", MPP_DOUBLE, 2, dims, 2, "standard_name", "ocean fraction at T-cell centers", "units", "none"); mpp_end_def(fid); mpp_put_var_value(fid, id_mask, mask); free(mask); mpp_close(fid); } } ocn_topog_file = (char **)malloc(ntiles*sizeof(char *)); axl_file = (char **)malloc(ntiles*sizeof(char *)); axo_file = (char **)malloc(ntiles*sizeof(char *)); lxo_file = (char **)malloc(ntiles*sizeof(char *)); for(n=0; n<ntiles; n++) { axl_file[n] = (char *)malloc(STRING*sizeof(char)); axo_file[n] = (char *)malloc(STRING*sizeof(char)); lxo_file[n] = (char *)malloc(STRING*sizeof(char)); ocn_topog_file[n] = (char *)malloc(STRING*sizeof(char)); sprintf(ocn_topog_file[n], "ocean_topog_tile%d.nc", n+1); sprintf(axl_file[n], "atmos_mosaic_tile%dXland_mosaic_tile%d.nc", n+1, n+1); sprintf(axo_file[n], "atmos_mosaic_tile%dXocean_mosaic_tile%d.nc", n+1, n+1); sprintf(lxo_file[n], "land_mosaic_tile%dXocean_mosaic_tile%d.nc", n+1, n+1); } for(n=0; n<ntiles; n++) { int *i1, *j1, *i2, *j2; double *area, *di, *dj; int nxgrid, i, j; int fid, dim_string, dim_ncells, dim_two, dims[2]; int id_contact, id_tile1_cell, id_tile2_cell; int id_xgrid_area, id_tile1_dist, id_tile2_dist; size_t start[4], nwrite[4]; char contact[STRING]; for(i=0; i<4; i++) { start[i] = 0; nwrite[i] = 1; } /* first calculate the atmXlnd exchange grid */ i1 = (int *)malloc(nx[n]*ny[n]*sizeof(int)); j1 = (int *)malloc(nx[n]*ny[n]*sizeof(int)); i2 = (int *)malloc(nx[n]*ny[n]*sizeof(int)); j2 = (int *)malloc(nx[n]*ny[n]*sizeof(int)); area = (double *)malloc(nx[n]*ny[n]*sizeof(double)); di = (double *)malloc(nx[n]*ny[n]*sizeof(double)); dj = (double *)malloc(nx[n]*ny[n]*sizeof(double)); /* write out the atmosXland exchange grid file, The file name will be atmos_mosaic_tile#Xland_mosaic_tile#.nc */ nxgrid = 0; for(j=0; j<ny[n]; j++) for(i=0; i<nx[n]; i++) { if(land_area[n][j*nx[n]+i] >0) { i1[nxgrid] = i+1; j1[nxgrid] = j+1; i2[nxgrid] = i+1; j2[nxgrid] = j+1; area[nxgrid] = land_area[n][j*nx[n]+i]; di[nxgrid] = 0; dj[nxgrid] = 0; nxgrid++; } } fid = mpp_open(axl_file[n], MPP_WRITE); sprintf(contact, "atmos_mosaic:tile%d::land_mosaic:tile%d", n+1, n+1); mpp_def_global_att(fid, "grid_version", grid_version); mpp_def_global_att(fid, "code_version", tagname); mpp_def_global_att(fid, "history", history); dim_string = mpp_def_dim(fid, "string", STRING); dim_ncells = mpp_def_dim(fid, "ncells", nxgrid); dim_two = mpp_def_dim(fid, "two", 2); id_contact = mpp_def_var(fid, "contact", MPP_CHAR, 1, &dim_string, 7, "standard_name", "grid_contact_spec", "contact_type", "exchange", "parent1_cell", "tile1_cell", "parent2_cell", "tile2_cell", "xgrid_area_field", "xgrid_area", "distant_to_parent1_centroid", "tile1_distance", "distant_to_parent2_centroid", "tile2_distance"); dims[0] = dim_ncells; dims[1] = dim_two; id_tile1_cell = mpp_def_var(fid, "tile1_cell", MPP_INT, 2, dims, 1, "standard_name", "parent_cell_indices_in_mosaic1"); id_tile2_cell = mpp_def_var(fid, "tile2_cell", MPP_INT, 2, dims, 1, "standard_name", "parent_cell_indices_in_mosaic2"); id_xgrid_area = mpp_def_var(fid, "xgrid_area", MPP_DOUBLE, 1, &dim_ncells, 2, "standard_name", "exchange_grid_area", "units", "m2"); id_tile1_dist = mpp_def_var(fid, "tile1_distance", MPP_DOUBLE, 2, dims, 1, "standard_name", "distance_from_parent1_cell_centroid"); id_tile2_dist = mpp_def_var(fid, "tile2_distance", MPP_DOUBLE, 2, dims, 1, "standard_name", "distance_from_parent2_cell_centroid"); mpp_end_def(fid); nwrite[0] = strlen(contact); mpp_put_var_value_block(fid, id_contact, start, nwrite, contact); nwrite[0] = nxgrid; mpp_put_var_value(fid, id_xgrid_area, area); mpp_put_var_value_block(fid, id_tile1_cell, start, nwrite, i1); mpp_put_var_value_block(fid, id_tile2_cell, start, nwrite, i2); mpp_put_var_value_block(fid, id_tile1_dist, start, nwrite, di); mpp_put_var_value_block(fid, id_tile2_dist, start, nwrite, di); start[1] = 1; mpp_put_var_value_block(fid, id_tile1_cell, start, nwrite, j1); mpp_put_var_value_block(fid, id_tile2_cell, start, nwrite, j2); mpp_put_var_value_block(fid, id_tile1_dist, start, nwrite, dj); mpp_put_var_value_block(fid, id_tile2_dist, start, nwrite, dj); mpp_close(fid); /* write out the atmosXocean exchange grid file, The file name will be atmos_mosaic_tile#Xocean_mosaic_tile#.nc */ nxgrid = 0; for(j=0; j<ny[n]; j++) for(i=0; i<nx[n]; i++) { if(ocean_area[n][j*nx[n]+i] >0) { i1[nxgrid] = i+1; j1[nxgrid] = j+1; i2[nxgrid] = i+1; j2[nxgrid] = j+1; area[nxgrid] = ocean_area[n][j*nx[n]+i]; di[nxgrid] = 0; dj[nxgrid] = 0; nxgrid++; } } fid = mpp_open(axo_file[n], MPP_WRITE); sprintf(contact, "atmos_mosaic:tile%d::ocean_mosaic:tile%d", n+1, n+1); mpp_def_global_att(fid, "grid_version", grid_version); mpp_def_global_att(fid, "code_version", tagname); mpp_def_global_att(fid, "history", history); dim_string = mpp_def_dim(fid, "string", STRING); dim_ncells = mpp_def_dim(fid, "ncells", nxgrid); dim_two = mpp_def_dim(fid, "two", 2); id_contact = mpp_def_var(fid, "contact", MPP_CHAR, 1, &dim_string, 7, "standard_name", "grid_contact_spec", "contact_type", "exchange", "parent1_cell", "tile1_cell", "parent2_cell", "tile2_cell", "xgrid_area_field", "xgrid_area", "distant_to_parent1_centroid", "tile1_distance", "distant_to_parent2_centroid", "tile2_distance"); dims[0] = dim_ncells; dims[1] = dim_two; id_tile1_cell = mpp_def_var(fid, "tile1_cell", MPP_INT, 2, dims, 1, "standard_name", "parent_cell_indices_in_mosaic1"); id_tile2_cell = mpp_def_var(fid, "tile2_cell", MPP_INT, 2, dims, 1, "standard_name", "parent_cell_indices_in_mosaic2"); id_xgrid_area = mpp_def_var(fid, "xgrid_area", MPP_DOUBLE, 1, &dim_ncells, 2, "standard_name", "exchange_grid_area", "units", "m2"); id_tile1_dist = mpp_def_var(fid, "tile1_distance", MPP_DOUBLE, 2, dims, 1, "standard_name", "distance_from_parent1_cell_centroid"); id_tile2_dist = mpp_def_var(fid, "tile2_distance", MPP_DOUBLE, 2, dims, 1, "standard_name", "distance_from_parent2_cell_centroid"); mpp_end_def(fid); start[1] = 0; nwrite[0] = strlen(contact); mpp_put_var_value_block(fid, id_contact, start, nwrite, contact); nwrite[0] = nxgrid; mpp_put_var_value(fid, id_xgrid_area, area); mpp_put_var_value_block(fid, id_tile1_cell, start, nwrite, i1); mpp_put_var_value_block(fid, id_tile2_cell, start, nwrite, i2); mpp_put_var_value_block(fid, id_tile1_dist, start, nwrite, di); mpp_put_var_value_block(fid, id_tile2_dist, start, nwrite, di); start[1] = 1; mpp_put_var_value_block(fid, id_tile1_cell, start, nwrite, j1); mpp_put_var_value_block(fid, id_tile2_cell, start, nwrite, j2); mpp_put_var_value_block(fid, id_tile1_dist, start, nwrite, dj); mpp_put_var_value_block(fid, id_tile2_dist, start, nwrite, dj); mpp_close(fid); /* write out landXocean exchange grid information */ fid = mpp_open(lxo_file[n], MPP_WRITE); sprintf(contact, "land_mosaic:tile%d::ocean_mosaic:tile%d", n+1, n+1); mpp_def_global_att(fid, "grid_version", grid_version); mpp_def_global_att(fid, "code_version", tagname); mpp_def_global_att(fid, "history", history); dim_string = mpp_def_dim(fid, "string", STRING); dim_ncells = mpp_def_dim(fid, "ncells", nxgrid); dim_two = mpp_def_dim(fid, "two", 2); id_contact = mpp_def_var(fid, "contact", MPP_CHAR, 1, &dim_string, 7, "standard_name", "grid_contact_spec", "contact_type", "exchange", "parent1_cell", "tile1_cell", "parent2_cell", "tile2_cell", "xgrid_area_field", "xgrid_area", "distant_to_parent1_centroid", "tile1_distance", "distant_to_parent2_centroid", "tile2_distance"); dims[0] = dim_ncells; dims[1] = dim_two; id_tile1_cell = mpp_def_var(fid, "tile1_cell", MPP_INT, 2, dims, 1, "standard_name", "parent_cell_indices_in_mosaic1"); id_tile2_cell = mpp_def_var(fid, "tile2_cell", MPP_INT, 2, dims, 1, "standard_name", "parent_cell_indices_in_mosaic2"); id_xgrid_area = mpp_def_var(fid, "xgrid_area", MPP_DOUBLE, 1, &dim_ncells, 2, "standard_name", "exchange_grid_area", "units", "m2"); id_tile1_dist = mpp_def_var(fid, "tile1_distance", MPP_DOUBLE, 2, dims, 1, "standard_name", "distance_from_parent1_cell_centroid"); id_tile2_dist = mpp_def_var(fid, "tile2_distance", MPP_DOUBLE, 2, dims, 1, "standard_name", "distance_from_parent2_cell_centroid"); mpp_end_def(fid); start[1] = 0; nwrite[0] = strlen(contact); mpp_put_var_value_block(fid, id_contact, start, nwrite, contact); nwrite[0] = nxgrid; mpp_put_var_value(fid, id_xgrid_area, area); mpp_put_var_value_block(fid, id_tile1_cell, start, nwrite, i1); mpp_put_var_value_block(fid, id_tile2_cell, start, nwrite, i2); mpp_put_var_value_block(fid, id_tile1_dist, start, nwrite, di); mpp_put_var_value_block(fid, id_tile2_dist, start, nwrite, di); start[1] = 1; mpp_put_var_value_block(fid, id_tile1_cell, start, nwrite, j1); mpp_put_var_value_block(fid, id_tile2_cell, start, nwrite, j2); mpp_put_var_value_block(fid, id_tile1_dist, start, nwrite, dj); mpp_put_var_value_block(fid, id_tile2_dist, start, nwrite, dj); mpp_close(fid); free(i1); free(j1); free(i2); free(j2); free(area); free(di); free(dj); } /*Fianlly create the coupler mosaic file mosaic_name.nc */ { int dim_string, dim_axo, dim_axl, dim_lxo, dims[2]; int id_amosaic_file, id_lmosaic_file, id_omosaic_file, id_otopog_file; int id_axo_file, id_axl_file, id_lxo_file; size_t start[4], nwrite[4]; for(i=0; i<4; i++) { start[i] = 0; nwrite[i] = 1; } printf("mosaic_file is %s\n", mosaic_file); fid = mpp_open(mosaic_file, MPP_WRITE); mpp_def_global_att(fid, "grid_version", grid_version); mpp_def_global_att(fid, "code_version", tagname); mpp_def_global_att(fid, "history", history); dim_string = mpp_def_dim(fid, "string", STRING); dim_axo = mpp_def_dim(fid, "nfile_aXo", ntiles); dim_axl = mpp_def_dim(fid, "nfile_aXl", ntiles); dim_lxo = mpp_def_dim(fid, "nfile_lXo", ntiles); id_amosaic_file = mpp_def_var(fid, "atm_mosaic_file", MPP_CHAR, 1, &dim_string, 1, "standard_name", "atmosphere_mosaic_file_name"); id_lmosaic_file = mpp_def_var(fid, "lnd_mosaic_file", MPP_CHAR, 1, &dim_string, 1, "standard_name", "land_mosaic_file_name"); id_omosaic_file = mpp_def_var(fid, "ocn_mosaic_file", MPP_CHAR, 1, &dim_string, 1, "standard_name", "ocean_mosaic_file_name"); id_otopog_file = mpp_def_var(fid, "ocn_topog_file", MPP_CHAR, 1, &dim_string, 1, "standard_name", "ocean_topog_file_name"); dims[0] = dim_axo; dims[1] = dim_string; id_axo_file = mpp_def_var(fid, "aXo_file", MPP_CHAR, 2, dims, 1, "standard_name", "atmXocn_exchange_grid_file"); dims[0] = dim_axl; dims[1] = dim_string; id_axl_file = mpp_def_var(fid, "aXl_file", MPP_CHAR, 2, dims, 1, "standard_name", "atmXlnd_exchange_grid_file"); dims[0] = dim_lxo; dims[1] = dim_string; id_lxo_file = mpp_def_var(fid, "lXo_file", MPP_CHAR, 2, dims, 1, "standard_name", "lndXocn_exchange_grid_file"); mpp_end_def(fid); nwrite[0] = strlen(lnd_mosaic); mpp_put_var_value_block(fid, id_lmosaic_file, start, nwrite, lnd_mosaic); mpp_put_var_value_block(fid, id_amosaic_file, start, nwrite, lnd_mosaic); mpp_put_var_value_block(fid, id_omosaic_file, start, nwrite, lnd_mosaic); for(n=0; n<ntiles; n++) { start[0] = n; nwrite[0] =1; nwrite[1] = strlen(ocn_topog_file[n]); mpp_put_var_value_block(fid, id_otopog_file, start, nwrite, ocn_topog_file[n]); nwrite[1] = strlen(axl_file[n]); mpp_put_var_value_block(fid, id_axl_file, start, nwrite, axl_file[n]); nwrite[1] = strlen(axo_file[n]); mpp_put_var_value_block(fid, id_axo_file, start, nwrite, axo_file[n]); nwrite[1] = strlen(lxo_file[n]); mpp_put_var_value_block(fid, id_lxo_file, start, nwrite, lxo_file[n]); } mpp_close(fid); } for(n=0; n<ntiles; n++) { free(axl_file[n]); free(axo_file[n]); free(lxo_file[n]); } free(axl_file); free(axo_file); free(lxo_file); printf("\n***** Congratulation! You have successfully run make_quick_mosaic\n"); 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", 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
/******************************************************************************* void setup_conserve_interp Setup the interpolation weight for conservative interpolation *******************************************************************************/ void setup_conserve_interp(int ntiles_in, const Grid_config *grid_in, int ntiles_out, Grid_config *grid_out, Interp_config *interp, unsigned int opcode) { int n, m, i, ii, jj, nx_in, ny_in, nx_out, ny_out, tile; size_t nxgrid, nxgrid2, nxgrid_prev; int *i_in, *j_in, *i_out, *j_out; int *tmp_t_in, *tmp_i_in, *tmp_j_in, *tmp_i_out, *tmp_j_out; double *tmp_di_in, *tmp_dj_in; double *xgrid_area, *tmp_area, *xgrid_clon, *xgrid_clat; double garea; typedef struct{ double *area; double *clon; double *clat; } CellStruct; CellStruct *cell_in; i_in = (int *)malloc(MAXXGRID * sizeof(int )); j_in = (int *)malloc(MAXXGRID * sizeof(int )); i_out = (int *)malloc(MAXXGRID * sizeof(int )); j_out = (int *)malloc(MAXXGRID * sizeof(int )); xgrid_area = (double *)malloc(MAXXGRID * sizeof(double)); if(opcode & CONSERVE_ORDER2) { xgrid_clon = (double *)malloc(MAXXGRID * sizeof(double)); xgrid_clat = (double *)malloc(MAXXGRID * sizeof(double)); } garea = 4*M_PI*RADIUS*RADIUS; if( opcode & READ) { for(n=0; n<ntiles_out; n++) { if( interp[n].file_exist ) { /* reading from file */ int *t_in, *ind; int fid, vid; nxgrid = read_mosaic_xgrid_size(interp[n].remap_file); t_in = (int *)malloc(nxgrid*sizeof(int )); ind = (int *)malloc(nxgrid*sizeof(int )); if(opcode & CONSERVE_ORDER1) read_mosaic_xgrid_order1(interp[n].remap_file, i_in, j_in, i_out, j_out, xgrid_area); else read_mosaic_xgrid_order2(interp[n].remap_file, i_in, j_in, i_out, j_out, xgrid_area, xgrid_clon, xgrid_clat); /*--- rescale the xgrid area */ for(i=0; i<nxgrid; i++) xgrid_area[i] *= garea; fid = mpp_open(interp[n].remap_file, MPP_READ); vid = mpp_get_varid(fid, "tile1"); mpp_get_var_value(fid, vid, t_in); mpp_close(fid); /*distribute the exchange grid on each pe according to target grid index*/ interp[n].nxgrid = 0; for(i=0; i<nxgrid; i++) { if( i_out[i] <= grid_out[n].iec && i_out[i] >= grid_out[n].isc && j_out[i] <= grid_out[n].jec && j_out[i] >= grid_out[n].jsc ) ind[interp[n].nxgrid++] = i; } interp[n].i_in = (int *)malloc(interp[n].nxgrid*sizeof(int )); interp[n].j_in = (int *)malloc(interp[n].nxgrid*sizeof(int )); interp[n].i_out = (int *)malloc(interp[n].nxgrid*sizeof(int )); interp[n].j_out = (int *)malloc(interp[n].nxgrid*sizeof(int )); interp[n].area = (double *)malloc(interp[n].nxgrid*sizeof(double)); interp[n].t_in = (int *)malloc(interp[n].nxgrid*sizeof(int )); for(i=0; i< interp[n].nxgrid; i++) { interp[n].i_in [i] = i_in [ind[i]]; interp[n].j_in [i] = j_in [ind[i]]; interp[n].t_in [i] = t_in [ind[i]] - 1; interp[n].i_out[i] = i_out[ind[i]] - grid_out[n].isc; interp[n].j_out[i] = j_out[ind[i]] - grid_out[n].jsc; interp[n].area [i] = xgrid_area[ind[i]]; } if(opcode & CONSERVE_ORDER2) { interp[n].di_in = (double *)malloc(interp[n].nxgrid*sizeof(double)); interp[n].dj_in = (double *)malloc(interp[n].nxgrid*sizeof(double)); for(i=0; i< interp[n].nxgrid; i++) { interp[n].di_in[i] = xgrid_clon[ind[i]]; interp[n].dj_in[i] = xgrid_clat[ind[i]]; } } free(t_in); free(ind); } } if(mpp_pe() == mpp_root_pe())printf("NOTE: Finish reading index and weight for conservative interpolation from file.\n"); } else { cell_in = (CellStruct *)malloc(ntiles_in * sizeof(CellStruct)); for(m=0; m<ntiles_in; m++) { nx_in = grid_in[m].nx; ny_in = grid_in[m].ny; cell_in[m].area = (double *)malloc(nx_in*ny_in*sizeof(double)); cell_in[m].clon = (double *)malloc(nx_in*ny_in*sizeof(double)); cell_in[m].clat = (double *)malloc(nx_in*ny_in*sizeof(double)); for(n=0; n<nx_in*ny_in; n++) { cell_in[m].area[n] = 0; cell_in[m].clon[n] = 0; cell_in[m].clat[n] = 0; } } for(n=0; n<ntiles_out; n++) { nx_out = grid_out[n].nxc; ny_out = grid_out[n].nyc; interp[n].nxgrid = 0; for(m=0; m<ntiles_in; m++) { double *mask; nx_in = grid_in[m].nx; ny_in = grid_in[m].ny; mask = (double *)malloc(nx_in*ny_in*sizeof(double)); for(i=0; i<nx_in*ny_in; i++) mask[i] = 1.0; if(opcode & CONSERVE_ORDER1) { nxgrid = create_xgrid_2dx2d_order1(&nx_in, &ny_in, &nx_out, &ny_out, grid_in[m].lonc, grid_in[m].latc, grid_out[n].lonc, grid_out[n].latc, mask, i_in, j_in, i_out, j_out, xgrid_area); } else if(opcode & CONSERVE_ORDER2) { int g_nxgrid; int *g_i_in, *g_j_in; double *g_area, *g_clon, *g_clat; nxgrid = create_xgrid_2dx2d_order2(&nx_in, &ny_in, &nx_out, &ny_out, grid_in[m].lonc, grid_in[m].latc, grid_out[n].lonc, grid_out[n].latc, mask, i_in, j_in, i_out, j_out, xgrid_area, xgrid_clon, xgrid_clat); /* For the purpose of bitiwise reproducing, the following operation is needed. */ g_nxgrid = nxgrid; mpp_sum_int(1, &g_nxgrid); if(g_nxgrid > 0) { g_i_in = (int *)malloc(g_nxgrid*sizeof(int )); g_j_in = (int *)malloc(g_nxgrid*sizeof(int )); g_area = (double *)malloc(g_nxgrid*sizeof(double)); g_clon = (double *)malloc(g_nxgrid*sizeof(double)); g_clat = (double *)malloc(g_nxgrid*sizeof(double)); mpp_gather_field_int (nxgrid, i_in, g_i_in); mpp_gather_field_int (nxgrid, j_in, g_j_in); mpp_gather_field_double(nxgrid, xgrid_area, g_area); mpp_gather_field_double(nxgrid, xgrid_clon, g_clon); mpp_gather_field_double(nxgrid, xgrid_clat, g_clat); for(i=0; i<g_nxgrid; i++) { ii = g_j_in[i]*nx_in+g_i_in[i]; cell_in[m].area[ii] += g_area[i]; cell_in[m].clon[ii] += g_clon[i]; cell_in[m].clat[ii] += g_clat[i]; } free(g_i_in); free(g_j_in); free(g_area); free(g_clon); free(g_clat); } } else mpp_error("conserve_interp: interp_method should be CONSERVE_ORDER1 or CONSERVE_ORDER2"); free(mask); if(nxgrid > 0) { nxgrid_prev = interp[n].nxgrid; interp[n].nxgrid += nxgrid; if(nxgrid_prev == 0 ) { interp[n].i_in = (int *)malloc(interp[n].nxgrid*sizeof(int )); interp[n].j_in = (int *)malloc(interp[n].nxgrid*sizeof(int )); interp[n].i_out = (int *)malloc(interp[n].nxgrid*sizeof(int )); interp[n].j_out = (int *)malloc(interp[n].nxgrid*sizeof(int )); interp[n].area = (double *)malloc(interp[n].nxgrid*sizeof(double)); interp[n].t_in = (int *)malloc(interp[n].nxgrid*sizeof(int )); for(i=0; i<interp[n].nxgrid; i++) { interp[n].t_in [i] = m; interp[n].i_in [i] = i_in [i]; interp[n].j_in [i] = j_in [i]; interp[n].i_out[i] = i_out[i]; interp[n].j_out[i] = j_out[i]; interp[n].area[i] = xgrid_area[i]; } if(opcode & CONSERVE_ORDER2) { interp[n].di_in = (double *)malloc(interp[n].nxgrid*sizeof(double)); interp[n].dj_in = (double *)malloc(interp[n].nxgrid*sizeof(double)); for(i=0; i<interp[n].nxgrid; i++) { jj = j_in [i]*nx_in+i_in [i]; interp[n].di_in [i] = xgrid_clon[i]/xgrid_area[i]; interp[n].dj_in [i] = xgrid_clat[i]/xgrid_area[i]; } } } else { tmp_i_in = interp[n].i_in; tmp_j_in = interp[n].j_in; tmp_i_out = interp[n].i_out; tmp_j_out = interp[n].j_out; tmp_area = interp[n].area; tmp_t_in = interp[n].t_in; interp[n].i_in = (int *)malloc(interp[n].nxgrid*sizeof(int )); interp[n].j_in = (int *)malloc(interp[n].nxgrid*sizeof(int )); interp[n].i_out = (int *)malloc(interp[n].nxgrid*sizeof(int )); interp[n].j_out = (int *)malloc(interp[n].nxgrid*sizeof(int )); interp[n].area = (double *)malloc(interp[n].nxgrid*sizeof(double)); interp[n].t_in = (int *)malloc(interp[n].nxgrid*sizeof(int )); for(i=0; i<nxgrid_prev; i++) { interp[n].t_in [i] = tmp_t_in [i]; interp[n].i_in [i] = tmp_i_in [i]; interp[n].j_in [i] = tmp_j_in [i]; interp[n].i_out[i] = tmp_i_out[i]; interp[n].j_out[i] = tmp_j_out[i]; interp[n].area [i] = tmp_area [i]; } for(i=0; i<nxgrid; i++) { ii = i + nxgrid_prev; interp[n].t_in [ii] = m; interp[n].i_in [ii] = i_in [i]; interp[n].j_in [ii] = j_in [i]; interp[n].i_out[ii] = i_out[i]; interp[n].j_out[ii] = j_out[i]; interp[n].area [ii] = xgrid_area[i]; } if(opcode & CONSERVE_ORDER2) { tmp_di_in = interp[n].di_in; tmp_dj_in = interp[n].dj_in; interp[n].di_in = (double *)malloc(interp[n].nxgrid*sizeof(double)); interp[n].dj_in = (double *)malloc(interp[n].nxgrid*sizeof(double)); for(i=0; i<nxgrid_prev; i++) { interp[n].di_in [i] = tmp_di_in [i]; interp[n].dj_in [i] = tmp_dj_in [i]; } for(i=0; i<nxgrid; i++) { ii = i + nxgrid_prev; jj = j_in [i]*nx_in+i_in [i]; interp[n].di_in [ii] = xgrid_clon[i]/xgrid_area[i]; interp[n].dj_in [ii] = xgrid_clat[i]/xgrid_area[i]; } free(tmp_di_in); free(tmp_dj_in); } free(tmp_t_in); free(tmp_i_in); free(tmp_j_in); free(tmp_i_out); free(tmp_j_out); free(tmp_area); } } /* if(nxgrid>0) */ } } if(opcode & CONSERVE_ORDER2) { /* subtrack the grid_in clon and clat to get the distance between xgrid and grid_in */ for(n=0; n<ntiles_in; n++) { double *area_in; double x1_in[50], y1_in[50], lon_in_avg, clon, clat; int j, n0, n1, n2, n3, n1_in; /* calcualte cell area */ nx_in = grid_in[n].nx; ny_in = grid_in[n].ny; area_in = (double *)malloc(nx_in*ny_in*sizeof(double)); get_grid_area(&nx_in, &ny_in, grid_in[n].lonc, grid_in[n].latc, area_in); for(j=0; j<ny_in; j++) for(i=0; i<nx_in; i++) { ii = j*nx_in + i; if(cell_in[n].area[ii] > 0) { if( fabs(cell_in[n].area[ii]-area_in[ii])/area_in[ii] < AREA_RATIO ) { cell_in[n].clon[ii] /= cell_in[n].area[ii]; cell_in[n].clat[ii] /= cell_in[n].area[ii]; } else { n0 = j*(nx_in+1)+i; n1 = j*(nx_in+1)+i+1; n2 = (j+1)*(nx_in+1)+i+1; n3 = (j+1)*(nx_in+1)+i; x1_in[0] = grid_in[n].lonc[n0]; y1_in[0] = grid_in[n].latc[n0]; x1_in[1] = grid_in[n].lonc[n1]; y1_in[1] = grid_in[n].latc[n1]; x1_in[2] = grid_in[n].lonc[n2]; y1_in[2] = grid_in[n].latc[n2]; x1_in[3] = grid_in[n].lonc[n3]; y1_in[3] = grid_in[n].latc[n3]; n1_in = fix_lon(x1_in, y1_in, 4, M_PI); lon_in_avg = avgval_double(n1_in, x1_in); clon = poly_ctrlon(x1_in, y1_in, n1_in, lon_in_avg); clat = poly_ctrlat (x1_in, y1_in, n1_in ); cell_in[n].clon[ii] = clon/area_in[ii]; cell_in[n].clat[ii] = clat/area_in[ii]; } } } free(area_in); } for(n=0; n<ntiles_out; n++) { for(i=0; i<interp[n].nxgrid; i++) { tile = interp[n].t_in[i]; ii = interp[n].j_in[i] * grid_in[tile].nx + interp[n].i_in[i]; interp[n].di_in[i] -= cell_in[tile].clon[ii]; interp[n].dj_in[i] -= cell_in[tile].clat[ii]; } } /* free the memory */ for(n=0; n<ntiles_in; n++) { free(cell_in[n].area); free(cell_in[n].clon); free(cell_in[n].clat); } free(cell_in); } if( opcode & WRITE) { /* write out remapping information */ for(n=0; n<ntiles_out; n++) { int nxgrid; nxgrid = interp[n].nxgrid; mpp_sum_int(1, &nxgrid); if(nxgrid > 0) { size_t start[4], nwrite[4]; int fid, dim_string, dim_ncells, dim_two, dims[4]; int id_xgrid_area, id_tile1_dist; int id_tile1_cell, id_tile2_cell, id_tile1; int *gdata_int, *ldata_int; double *gdata_dbl; fid = mpp_open( interp[n].remap_file, MPP_WRITE); dim_string = mpp_def_dim(fid, "string", STRING); dim_ncells = mpp_def_dim(fid, "ncells", nxgrid); dim_two = mpp_def_dim(fid, "two", 2); dims[0] = dim_ncells; dims[1] = dim_two; id_tile1 = mpp_def_var(fid, "tile1", NC_INT, 1, &dim_ncells, 1, "standard_name", "tile_number_in_mosaic1"); id_tile1_cell = mpp_def_var(fid, "tile1_cell", NC_INT, 2, dims, 1, "standard_name", "parent_cell_indices_in_mosaic1"); id_tile2_cell = mpp_def_var(fid, "tile2_cell", NC_INT, 2, dims, 1, "standard_name", "parent_cell_indices_in_mosaic2"); id_xgrid_area = mpp_def_var(fid, "xgrid_area", NC_DOUBLE, 1, &dim_ncells, 2, "standard_name", "exchange_grid_area", "units", "m2"); if(opcode & CONSERVE_ORDER2) id_tile1_dist = mpp_def_var(fid, "tile1_distance", NC_DOUBLE, 2, dims, 1, "standard_name", "distance_from_parent1_cell_centroid"); mpp_end_def(fid); for(i=0; i<4; i++) { start[i] = 0; nwrite[i] = 1; } nwrite[0] = nxgrid; gdata_int = (int *)malloc(nxgrid*sizeof(int)); if(interp[n].nxgrid>0) ldata_int = (int *)malloc(interp[n].nxgrid*sizeof(int)); gdata_dbl = (double *)malloc(nxgrid*sizeof(double)); mpp_gather_field_double(interp[n].nxgrid, interp[n].area, gdata_dbl); mpp_put_var_value(fid, id_xgrid_area, gdata_dbl); mpp_gather_field_int(interp[n].nxgrid, interp[n].t_in, gdata_int); for(i=0; i<nxgrid; i++) gdata_int[i]++; mpp_put_var_value(fid, id_tile1, gdata_int); mpp_gather_field_int(interp[n].nxgrid, interp[n].i_in, gdata_int); for(i=0; i<nxgrid; i++) gdata_int[i]++; mpp_put_var_value_block(fid, id_tile1_cell, start, nwrite, gdata_int); if(opcode & CONSERVE_ORDER2) { mpp_gather_field_double(interp[n].nxgrid, interp[n].di_in, gdata_dbl); mpp_put_var_value_block(fid, id_tile1_dist, start, nwrite, gdata_dbl); } for(i=0; i<interp[n].nxgrid; i++) ldata_int[i] = interp[n].i_out[i] + grid_out[n].isc + 1; mpp_gather_field_int(interp[n].nxgrid, ldata_int, gdata_int); mpp_put_var_value_block(fid, id_tile2_cell, start, nwrite, gdata_int); mpp_gather_field_int(interp[n].nxgrid, interp[n].j_in, gdata_int); for(i=0; i<nxgrid; i++) gdata_int[i]++; start[1] = 1; mpp_put_var_value_block(fid, id_tile1_cell, start, nwrite, gdata_int); if(opcode & CONSERVE_ORDER2) { mpp_gather_field_double(interp[n].nxgrid, interp[n].dj_in, gdata_dbl); mpp_put_var_value_block(fid, id_tile1_dist, start, nwrite, gdata_dbl); } for(i=0; i<interp[n].nxgrid; i++) ldata_int[i] = interp[n].j_out[i] + grid_out[n].jsc + 1; mpp_gather_field_int(interp[n].nxgrid, ldata_int, gdata_int); mpp_put_var_value_block(fid, id_tile2_cell, start, nwrite, gdata_int); free(gdata_int); free(gdata_dbl); if(interp[n].nxgrid>0)free(ldata_int); mpp_close(fid); } } } if(mpp_pe() == mpp_root_pe())printf("NOTE: done calculating index and weight for conservative interpolation\n"); } /* get target grid area if needed */ if( opcode & TARGET ) { for(n=0; n<ntiles_out; n++) { nx_out = grid_out[n].nxc; ny_out = grid_out[n].nyc; grid_out[n].area = (double *)malloc(nx_out*ny_out*sizeof(double)); get_grid_area(&nx_out,&ny_out, grid_out[n].lonc, grid_out[n].latc, grid_out[n].area); } } free(i_in); free(j_in); free(i_out); free(j_out); free(xgrid_area); if(opcode & CONSERVE_ORDER2) { free(xgrid_clon); free(xgrid_clat); } }; /* setup_conserve_interp */
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 */