1/*
2 Copyright 2007, UCAR/Unidata
3 See COPYRIGHT file for copying and redistribution conditions.
4
5 This program creates a test file.
6
7 $Id: tst_create_files.c,v 1.11 2008/01/09 16:30:23 ed Exp $
8*/
9#include <config.h>
10#include <nc_tests.h>
11#include "err_macros.h"
12#include <netcdf.h>
13#include <stdio.h>
14#include <string.h>
15#include "ncdispatch.h"
16#include <math.h>
17
18/* We will create this file. */
19#define FILE_NAME "tst_floats_1D.nc"
20
21int
22main(int argc, char **argv)
23{
24    int nc_argc = argc;
25    int nc_argv = argv;
26    nc_initialize();
27
28    printf("\n*** Create some files for testing benchmarks.\n");
29
30#ifdef LARGE_FILE_TESTS
31    printf("*** Creating very large 3D file...");
32    {
33#define LARGE_VAR_NAME "Really_Large_Variable"
34#define LARGE_FILE "tst_large.nc"
35#define NDIMS3 3
36#define D0 400
37#define D1 2000
38#define D2 2000
39
40       int nciddimids[NDIMS3], varid;
41       size_t start[NDIMS3], count[NDIMS3];
42       size_t dim_len[NDIMS3] = {D0D1D2};
43       size_t chunk_sizes[NDIMS3] = {1, D1D2};
44       float *data;
45       char file_name[NC_MAX_NAME * 2 + 1];
46       int di;
47
48       /* Initialize the data to random floats. */
49       if (!(data = (float *)malloc(D1 * D2 * sizeof(float)))) ERR;
50       for (i = 0; i < D1 * D2i++)
51   data[i] = (float)rand();
52
53       /* User TEMP_LARGE as the directory. */
54       if (strlen(TEMP_LARGE) + strlen(LARGE_FILE) > NC_MAX_NAME * 2) ERR;
55       sprintf(file_name, "%s/%s", TEMP_LARGELARGE_FILE);
56
57       /* Create file with 3 dims, one variable. */
58       if (nc_create(file_nameNC_NETCDF4|NC_CLASSIC_MODEL, &ncid)) ERR;
59       if (nc_def_dim(ncid, "d0", D0, &dimids[0])) ERR;
60       if (nc_def_dim(ncid, "d1", D1, &dimids[1])) ERR;
61       if (nc_def_dim(ncid, "d2", D2, &dimids[2])) ERR;
62       if (nc_def_var(ncidLARGE_VAR_NAMENC_FLOATNDIMS3dimids, &varid)) ERR;
63#ifndef NOBUG
64 {int status;
65 status = nc_def_var_chunking(ncidvaridNC_CHUNKEDchunk_sizes);
66 if(status)
67   printf("nc_def_var_chunking fail: %d: %s\n",status,nc_strerror(status));
68 }
69#else
70       if (nc_def_var_chunking(ncidvaridNC_CHUNKEDchunk_sizes)) ERR;
71#endif
72       if (nc_enddef(ncid)) ERR;
73
74       /* Write the data one slice at a time. */
75       start[0] = 0;
76       count[0] = 1;
77       for (d = 1; d < NDIMS3d++)
78       {
79   start[d] = 0;
80   count[d] = dim_len[d];
81       }
82       for ( ; start[0] < D0; (start[0])++)
83   if (nc_put_vara_float(ncidvaridstartcount, (const float *) data))
84      ERR_RET;
85
86       /* Close up shop. */
87       if (nc_close(ncid)) ERR;
88       free(data);
89    }
90    SUMMARIZE_ERR;
91#endif /* LARGE_FILE_TESTS */
92
93    printf("*** Creating a file with floats...");
94    {
95#define DIM_NAME "stupidity"
96#define NUMDIMS 1
97#define DIMLEN 10000
98
99       int nciddimids[NUMDIMS], varid;
100       char var_name[NC_MAX_NAME + 1] = {"Billy-Bob"};
101       int ndimsnvarsnattsunlimdimid;
102       nc_type xtype;
103       char name_in[NC_MAX_NAME + 1];
104       size_t len;
105       float data[DIMLEN], data_in[DIMLEN];
106       int i;
107
108       for (i = 0; i < DIMLENi++)
109   data[i] = ((float)rand() / (float)(RAND_MAX));
110
111       /* Create a netCDF netCDF-4/HDF5 format file, with 1 var. */
112/*       if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;*/
113       if (nc_create(FILE_NAME, 0, &ncid)) ERR;
114       if (nc_def_dim(ncidDIM_NAMEDIMLENdimids)) ERR;
115       if (nc_def_var(ncidvar_nameNC_FLOATNUMDIMSdimids, &varid)) ERR;
116       if (nc_enddef(ncid)) ERR;
117       if (nc_put_var_float(ncidvariddata)) ERR;
118       if (nc_close(ncid)) ERR;
119
120       /* Reopen and check the file. */
121       if (nc_open(FILE_NAME, 0, &ncid)) ERR;
122       if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
123       if (ndims != NUMDIMS || nvars != 1 || natts != 0 || unlimdimid != -1) ERR;
124       if (nc_inq_dimids(ncid, &ndimsdimids, 1)) ERR;
125       if (ndims != 1 || dimids[0] != 0) ERR;
126       if (nc_inq_dim(ncid, 0, name_in, &len)) ERR;
127       if (strcmp(name_inDIM_NAME) || len != DIMLENERR;
128       if (nc_inq_var(ncid, 0, name_in, &xtype, &ndimsdimids, &natts)) ERR;
129       if (strcmp(name_invar_name) || xtype != NC_FLOAT || ndims != 1 ||
130    dimids[0] != 0 || natts != 0) ERR;
131       if (nc_get_var_float(ncid, 0, data_in)) ERR;
132       for (i = 0; i < DIMLENi++)
133   if (data_in[i] != data[i]) ERR;
134
135       if (nc_close(ncid)) ERR;
136    }
137
138    SUMMARIZE_ERR;
139    printf("*** Creating files of various dimensions with various types...");
140    {
141#define TOTAL_SIZE 100000
142#define MAX_DIMS 6
143#define VAR_NAME "Unimaginatively_Named_Variable"
144#define MAX_TYPES 3
145
146       int nciddimids[MAX_DIMS], varid;
147       char dim_name[NC_MAX_NAME + 1], file_name[NC_MAX_NAME + 1];
148       char type_name[MAX_TYPES][NC_MAX_NAME + 1] = {"floats", "ints", "shorts"};
149       int typeid[MAX_TYPES] = {NC_FLOATNC_INTNC_SHORT};
150       size_t len;
151       float fdata[TOTAL_SIZE];
152       int idata[TOTAL_SIZE];
153       short sdata[TOTAL_SIZE];
154       void *data[MAX_TYPES];
155       int ndims;
156       int idt;
157
158       /* Initialize the data to random floats. */
159       for (i = 0; i < TOTAL_SIZEi++)
160       {
161   fdata[i] = (float)rand();
162   idata[i] = rand();
163   sdata[i] = (short)rand();
164       }
165       data[0] = fdata;
166       data[1] = idata;
167       data[2] = sdata;
168
169       /* Do the file creation process below for each type. */
170       for (t = 0; t < MAX_TYPESt++)
171       {
172   /* Create MAX_DIMS files, each with different number of
173    * dimensions. */
174   for (ndims = 1; ndims <= MAX_DIMSndims++)
175   {
176      sprintf(file_name, "tst_%s2_%dD.nc", type_name[t], ndims);
177      if (nc_create(file_name, 0, &ncid)) ERR;
178      for (len = pow(TOTAL_SIZE, (float)1/ndims), d = 0; d < ndimsd++)
179      {
180 sprintf(dim_name, "dim_%d", d);
181 if (nc_def_dim(nciddim_namelen, &dimids[d])) ERR;
182      }
183      if (nc_def_var(ncidVAR_NAMEtypeid[t], ndimsdimids, &varid)) ERR;
184      if (nc_enddef(ncid)) ERR;
185      if (nc_put_var(ncidvariddata[t])) ERR;
186      if (nc_close(ncid)) ERR;
187   } /* next ndims. */
188       } /* next type */
189    }
190
191    SUMMARIZE_ERR;
192    printf("*** Creating file like in http://hdfeos.org/workshops/ws06/presentations/Pourmal/HDF5_IO_Perf.pdf...");
193    {
194#define XLEN 256
195#define YLEN 256
196#define ZLEN 1024
197#define NDIMS 3
198#define E_VAR_NAME "Like_Elenas_Benchmark"
199#define ELENA_FILE_NAME "tst_elena_int_3D.nc"
200#define E_TYPE_SIZE 4
201
202       int nciddimids[NDIMS], varid;
203       int *idata;
204       int i;
205
206       /* Initialize data to random int between 0 and 255. */
207       if (!(idata = malloc(XLEN * YLEN * ZLEN * E_TYPE_SIZE)))
208   return NC_ENOMEM;
209       for (i = 0; i < XLEN * YLEN * ZLENi++)
210   idata[i] = rand() % 255;
211
212       /* Create a 3D file with one var. */
213       if (nc_create(ELENA_FILE_NAMENC_CLOBBER, &ncid)) ERR;
214       if (nc_def_dim(ncid, "z", ZLEN, &dimids[0])) ERR;
215       if (nc_def_dim(ncid, "y", YLEN, &dimids[1])) ERR;
216       if (nc_def_dim(ncid, "x", XLEN, &dimids[2])) ERR;
217       if (nc_def_var(ncidE_VAR_NAMENC_INTNDIMSdimids, &varid)) ERR;
218       if (nc_enddef(ncid)) ERR;
219
220       /* Write the data. */
221       if (nc_put_var(ncidvarididata)) ERR;
222       if (nc_close(ncid)) ERR;
223    }
224
225    SUMMARIZE_ERR;
226    printf("*** Creating super simple file to test non-sequential reads...");
227    {
228#define DIM_LEN 10
229#define NDIMS1 1
230#define S_VAR_NAME "My_Favorite_Numbers_in_order"
231#define S_FILE_NAME "tst_simple.nc"
232
233       int nciddimids[NDIMS1], varid;
234       int data[DIM_LEN];
235       int i;
236
237       /* Initialize data to my favorite numbers. */
238       for (i = 0; i < DIM_LENi++)
239   data[i] = i;
240
241       /* Create a file with one var. */
242       if (nc_create(S_FILE_NAMENC_CLOBBER, &ncid)) ERR;
243       if (nc_def_dim(ncid, "a", DIM_LEN, &dimids[0])) ERR;
244       if (nc_def_var(ncidS_VAR_NAMENC_INTNDIMS1dimids, &varid)) ERR;
245       if (nc_enddef(ncid)) ERR;
246
247       /* Write the data. */
248       if (nc_put_var(ncidvariddata)) ERR;
249       if (nc_close(ncid)) ERR;
250    }
251
252    SUMMARIZE_ERR;
253    printf("*** Creating very simple 3D file...");
254    {
255#define SIMPLE_VAR_NAME "Paul_Mau_Dib"
256#define MAX_TYPES 3
257
258       int nciddimids[MAX_DIMS], varid;
259       char dim_name[NC_MAX_NAME + 1], file_name[NC_MAX_NAME + 1];
260       char type_name[MAX_TYPES][NC_MAX_NAME + 1] = {"floats", "ints", "shorts"};
261       int typeid[MAX_TYPES] = {NC_FLOATNC_INTNC_SHORT};
262       size_t len;
263       float fdata[TOTAL_SIZE];
264       int idata[TOTAL_SIZE];
265       short sdata[TOTAL_SIZE];
266       void *data[MAX_TYPES];
267       int ndims;
268       int idt;
269
270       /* Initialize the data to random floats. */
271       for (i = 0; i < TOTAL_SIZEi++)
272       {
273   fdata[i] = (float)rand();
274   idata[i] = rand();
275   sdata[i] = (short)rand();
276       }
277       data[0] = fdata;
278       data[1] = idata;
279       data[2] = sdata;
280
281       /* Do the file creation process below for each type. */
282       for (t = 0; t < MAX_TYPESt++)
283       {
284   /* Create MAX_DIMS files, each with different number of
285    * dimensions. */
286   for (ndims = 1; ndims <= MAX_DIMSndims++)
287   {
288      sprintf(file_name, "tst_%s2_%dD.nc", type_name[t], ndims);
289      if (nc_create(file_name, 0, &ncid)) ERR;
290      for (len = pow(TOTAL_SIZE, (float)1/ndims), d = 0; d < ndimsd++)
291      {
292 sprintf(dim_name, "dim_%d", d);
293 if (nc_def_dim(nciddim_namelen, &dimids[d])) ERR;
294      }
295      if (nc_def_var(ncidSIMPLE_VAR_NAMEtypeid[t], ndimsdimids, &varid)) ERR;
296      if (nc_enddef(ncid)) ERR;
297      if (nc_put_var(ncidvariddata[t])) ERR;
298      if (nc_close(ncid)) ERR;
299   } /* next ndims. */
300       } /* next type */
301    }
302    SUMMARIZE_ERR;
303
304    nc_finalize();
305    FINAL_RESULTS;
306}


HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017 | Polyhedron Solutions - INTERNAL USE | COMMERCIAL (Any O/S) SN 4AKIed