2021-08-24 14:45:38 +08:00
|
|
|
/* This is part of the netCDF package.
|
|
|
|
|
Copyright 2021 University Corporation for Atmospheric Research/Unidata
|
|
|
|
|
See COPYRIGHT file for conditions of use.
|
|
|
|
|
|
|
|
|
|
Test quantization of netcdf-4 variables. Quantization is the
|
|
|
|
|
zeroing-out of bits in float or double data beyond a desired
|
|
|
|
|
precision.
|
|
|
|
|
|
|
|
|
|
Ed Hartnett, 8/19/21
|
2022-01-25 06:22:24 +08:00
|
|
|
Dennis Heimbigner, 1/16/22
|
2021-08-24 14:45:38 +08:00
|
|
|
*/
|
|
|
|
|
|
2022-02-20 06:48:08 +08:00
|
|
|
#include <math.h> /* Define fabs(), powf(), round() */
|
2021-08-24 14:45:38 +08:00
|
|
|
#include <nc_tests.h>
|
|
|
|
|
#include "err_macros.h"
|
|
|
|
|
#include "netcdf.h"
|
|
|
|
|
|
2021-08-26 20:37:45 +08:00
|
|
|
#define TEST "tst_quantize"
|
2021-08-24 14:45:38 +08:00
|
|
|
#define FILE_NAME "tst_quantize.nc"
|
2021-09-01 16:24:28 +08:00
|
|
|
#define NDIM1 1
|
2021-08-24 14:45:38 +08:00
|
|
|
#define DIM_NAME_1 "meters_along_canal"
|
2021-08-26 21:21:07 +08:00
|
|
|
#define DIM_LEN_3 3
|
|
|
|
|
#define DIM_LEN_1 1
|
2021-08-29 15:04:09 +08:00
|
|
|
#define DIM_LEN_5 5
|
2021-09-01 16:24:28 +08:00
|
|
|
#define DIM_LEN_8 8
|
2021-08-24 14:45:38 +08:00
|
|
|
#define VAR_NAME_1 "Amsterdam_houseboat_location"
|
2021-08-25 15:54:25 +08:00
|
|
|
#define VAR_NAME_2 "Amsterdam_street_noise_decibels"
|
2021-08-26 21:21:07 +08:00
|
|
|
#define NSD_3 3
|
|
|
|
|
#define NSD_9 9
|
2021-08-24 14:45:38 +08:00
|
|
|
|
2021-08-29 22:42:21 +08:00
|
|
|
/* This var used to help print a float in hex. */
|
|
|
|
|
char pf_str[20];
|
|
|
|
|
|
|
|
|
|
/* This struct allows us to treat float as uint32_t
|
|
|
|
|
* types. */
|
|
|
|
|
union FU {
|
|
|
|
|
float f;
|
|
|
|
|
uint32_t u;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* This struct allows us to treat double points as uint64_t
|
|
|
|
|
* types. */
|
|
|
|
|
union DU {
|
|
|
|
|
double d;
|
|
|
|
|
uint64_t u;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* This function prints a float as hex. */
|
|
|
|
|
char *
|
|
|
|
|
pf(float myf)
|
|
|
|
|
{
|
|
|
|
|
union {
|
|
|
|
|
float f;
|
|
|
|
|
uint32_t u;
|
|
|
|
|
} fu;
|
|
|
|
|
fu.f = myf;
|
|
|
|
|
sprintf(pf_str, "0x%x", fu.u);
|
|
|
|
|
return pf_str;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This function prints a double as hex. */
|
|
|
|
|
char *
|
|
|
|
|
pd(double myd)
|
|
|
|
|
{
|
|
|
|
|
union {
|
|
|
|
|
double d;
|
|
|
|
|
uint64_t u;
|
|
|
|
|
} du;
|
|
|
|
|
du.d = myd;
|
2022-02-20 06:48:08 +08:00
|
|
|
sprintf(pf_str, "0x%llx", (unsigned long long)du.u);
|
2021-08-29 22:42:21 +08:00
|
|
|
return pf_str;
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-24 14:45:38 +08:00
|
|
|
int
|
|
|
|
|
main(int argc, char **argv)
|
|
|
|
|
{
|
2022-01-25 06:22:24 +08:00
|
|
|
#ifdef TESTNCZARR
|
|
|
|
|
const char* template = NULL;
|
|
|
|
|
char file_url[4096];
|
|
|
|
|
|
|
|
|
|
if(argc == 1)
|
|
|
|
|
{fprintf(stderr,"usage: test_quantize <zarr-url-template>\n"); exit(1);}
|
|
|
|
|
|
|
|
|
|
template = argv[1];
|
|
|
|
|
|
|
|
|
|
snprintf(file_url,sizeof(file_url),template,FILE_NAME);
|
|
|
|
|
|
|
|
|
|
#undef FILE_NAME
|
|
|
|
|
#define FILE_NAME file_url
|
|
|
|
|
#endif
|
|
|
|
|
|
2021-08-24 14:45:38 +08:00
|
|
|
printf("\n*** Testing netcdf-4 variable quantization functions.\n");
|
2021-08-25 16:17:57 +08:00
|
|
|
printf("**** testing quantization setting and error conditions...");
|
2021-08-24 15:53:16 +08:00
|
|
|
{
|
2021-08-29 15:13:39 +08:00
|
|
|
int ncid, dimid, varid1, varid2;
|
|
|
|
|
int quantize_mode_in, nsd_in;
|
|
|
|
|
|
2022-01-25 06:22:24 +08:00
|
|
|
#ifndef TESTNCZARR
|
2021-08-29 15:13:39 +08:00
|
|
|
/* Create a netcdf classic file with one var. Attempt
|
|
|
|
|
* quantization. It will not work. */
|
|
|
|
|
if (nc_create(FILE_NAME, NC_CLOBBER, &ncid)) ERR;
|
|
|
|
|
if (nc_def_dim(ncid, DIM_NAME_1, DIM_LEN_3, &dimid)) ERR;
|
2021-09-01 16:24:28 +08:00
|
|
|
if (nc_def_var(ncid, VAR_NAME_1, NC_FLOAT, NDIM1, &dimid, &varid1)) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3) != NC_ENOTNC4) ERR;
|
|
|
|
|
if (nc_inq_var_quantize(ncid, varid1, &quantize_mode_in, &nsd_in) != NC_ENOTNC4) ERR;
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
#endif
|
2021-08-29 15:13:39 +08:00
|
|
|
|
|
|
|
|
/* Create a netcdf-4 file with two vars. Attempt
|
|
|
|
|
* quantization. It will work, eventually... */
|
|
|
|
|
if (nc_create(FILE_NAME, NC_NETCDF4|NC_CLOBBER, &ncid)) ERR;
|
|
|
|
|
if (nc_def_dim(ncid, DIM_NAME_1, DIM_LEN_3, &dimid)) ERR;
|
2021-09-01 16:24:28 +08:00
|
|
|
if (nc_def_var(ncid, VAR_NAME_1, NC_FLOAT, NDIM1, &dimid, &varid1)) ERR;
|
|
|
|
|
if (nc_def_var(ncid, VAR_NAME_2, NC_DOUBLE, NDIM1, &dimid, &varid2)) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
|
|
|
|
|
/* Bad varid. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, NC_GLOBAL, NC_QUANTIZE_BITGROOM, NSD_3) != NC_EGLOBAL) ERR;
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid2 + 1, NC_QUANTIZE_BITGROOM, NSD_3) != NC_ENOTVAR) ERR;
|
|
|
|
|
/* Invalid values. */
|
2022-02-19 03:00:37 +08:00
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITROUND + 1, NSD_3) != NC_EINVAL) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, -1) != NC_EINVAL) ERR;
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NC_QUANTIZE_MAX_FLOAT_NSD + 1) != NC_EINVAL) ERR;
|
2022-02-19 03:00:37 +08:00
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITROUND + 1, 3) != NC_EINVAL) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITGROOM, -1) != NC_EINVAL) ERR;
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITGROOM, NC_QUANTIZE_MAX_DOUBLE_NSD + 1) != NC_EINVAL) ERR;
|
2021-09-10 20:10:20 +08:00
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITGROOM, 0) != NC_EINVAL) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
|
|
|
|
|
/* This will work. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
if (nc_inq_var_quantize(ncid, varid1, &quantize_mode_in, &nsd_in)) ERR;
|
|
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM) ERR;
|
|
|
|
|
if (nsd_in != NSD_3) ERR;
|
|
|
|
|
|
|
|
|
|
/* Wait, I changed my mind! Let's turn off quantization. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_NOQUANTIZE, 0)) ERR;
|
|
|
|
|
if (nc_inq_var_quantize(ncid, varid1, &quantize_mode_in, &nsd_in)) ERR;
|
|
|
|
|
if (quantize_mode_in != NC_NOQUANTIZE) ERR;
|
|
|
|
|
if (nsd_in != 0) ERR;
|
|
|
|
|
|
|
|
|
|
/* Changed my mind again, turn it on. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
|
|
|
|
|
/* I changed my mind again! Turn it off! */
|
2021-09-10 20:10:20 +08:00
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_NOQUANTIZE, 0)) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
if (nc_inq_var_quantize(ncid, varid1, &quantize_mode_in, &nsd_in)) ERR;
|
|
|
|
|
if (quantize_mode_in != NC_NOQUANTIZE) ERR;
|
|
|
|
|
if (nsd_in != 0) ERR;
|
|
|
|
|
|
|
|
|
|
/* Changed my mind again, turn it on. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
|
|
|
|
|
/* This also will work for double. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITGROOM, NSD_9)) ERR;
|
|
|
|
|
if (nc_inq_var_quantize(ncid, varid2, &quantize_mode_in, &nsd_in)) ERR;
|
|
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM) ERR;
|
|
|
|
|
if (nsd_in != NSD_9) ERR;
|
|
|
|
|
|
|
|
|
|
/* End define mode. */
|
|
|
|
|
if (nc_enddef(ncid)) ERR;
|
|
|
|
|
|
|
|
|
|
/* This will not work, it's too late! */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3) != NC_ELATEDEF) ERR;
|
|
|
|
|
|
|
|
|
|
/* Close the file. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Open the file and check. */
|
|
|
|
|
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
/* Don't assume the varid !!! */
|
|
|
|
|
if (nc_inq_varid(ncid, VAR_NAME_1, &varid1)) ERR;
|
|
|
|
|
if (nc_inq_varid(ncid, VAR_NAME_2, &varid2)) ERR;
|
|
|
|
|
if (nc_inq_var_quantize(ncid, varid1, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM) ERR;
|
|
|
|
|
if (nsd_in != NSD_3) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_var_quantize(ncid, varid2, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM) ERR;
|
|
|
|
|
if (nsd_in != NSD_9) ERR;
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
2021-08-25 16:17:57 +08:00
|
|
|
}
|
|
|
|
|
SUMMARIZE_ERR;
|
2021-08-26 20:37:45 +08:00
|
|
|
|
|
|
|
|
#define NX_BIG 100
|
|
|
|
|
#define NY_BIG 100
|
|
|
|
|
#define NTYPES 9
|
|
|
|
|
#define VAR_NAME "Amsterdam_coffeeshop_location"
|
|
|
|
|
#define X_NAME "distance_from_center"
|
|
|
|
|
#define Y_NAME "distance_along_canal"
|
|
|
|
|
#define NDIM2 2
|
|
|
|
|
|
|
|
|
|
printf("**** testing quantization handling of non-floats...");
|
|
|
|
|
{
|
|
|
|
|
int ncid;
|
|
|
|
|
int dimid[NDIM2];
|
|
|
|
|
int varid;
|
|
|
|
|
int nsd_in, quantize_mode;
|
2021-08-29 15:13:39 +08:00
|
|
|
int nsd_out = 3;
|
2022-01-25 06:22:24 +08:00
|
|
|
#ifdef TESTNCZARR
|
|
|
|
|
char file_name[4096];
|
|
|
|
|
#else
|
2021-08-29 15:13:39 +08:00
|
|
|
char file_name[NC_MAX_NAME + 1];
|
2022-01-25 06:22:24 +08:00
|
|
|
#endif
|
2021-08-29 15:13:39 +08:00
|
|
|
int xtype[NTYPES] = {NC_CHAR, NC_SHORT, NC_INT, NC_BYTE, NC_UBYTE,
|
2021-08-26 20:37:45 +08:00
|
|
|
NC_USHORT, NC_UINT, NC_INT64, NC_UINT64};
|
2021-08-29 15:13:39 +08:00
|
|
|
int t;
|
|
|
|
|
|
|
|
|
|
for (t = 0; t < NTYPES; t++)
|
|
|
|
|
{
|
|
|
|
|
sprintf(file_name, "%s_bitgroom_type_%d.nc", TEST, xtype[t]);
|
2022-01-25 06:22:24 +08:00
|
|
|
#ifdef TESTNCZARR
|
|
|
|
|
{
|
|
|
|
|
char url[4096];
|
|
|
|
|
snprintf(url,sizeof(url),template,file_name);
|
|
|
|
|
strcpy(file_name,url);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2021-08-29 15:13:39 +08:00
|
|
|
/* Create file. */
|
|
|
|
|
if (nc_create(file_name, NC_NETCDF4, &ncid)) ERR;
|
|
|
|
|
if (nc_def_dim(ncid, X_NAME, NX_BIG, &dimid[0])) ERR;
|
|
|
|
|
if (nc_def_dim(ncid, Y_NAME, NY_BIG, &dimid[1])) ERR;
|
|
|
|
|
if (nc_def_var(ncid, VAR_NAME, xtype[t], NDIM2, dimid, &varid)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Bitgroom filter returns NC_EINVAL because this is not an
|
|
|
|
|
* NC_FLOAT or NC_DOULBE. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid, NC_QUANTIZE_BITGROOM, nsd_out) != NC_EINVAL) ERR;
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Check file. */
|
|
|
|
|
{
|
|
|
|
|
if (nc_open(file_name, NC_NETCDF4, &ncid)) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_varid(ncid,VAR_NAME,&varid)) ERR;
|
Enhance/Fix filter support
re: Discussion https://github.com/Unidata/netcdf-c/discussions/2214
The primary change is to support so-called "standard filters".
A standard filter is one that is defined by the following
netcdf-c API:
````
int nc_def_var_XXX(int ncid, int varid, size_t nparams, unsigned* params);
int nc_inq_var_XXXX(int ncid, int varid, int* usefilterp, unsigned* params);
````
So for example, zstandard would be a standard filter by defining
the functions *nc_def_var_zstandard* and *nc_inq_var_zstandard*.
In order to define these functions, we need a new dispatch function:
````
int nc_inq_filter_avail(int ncid, unsigned filterid);
````
This function, combined with the existing filter API can be used
to implement arbitrary standard filters using a simple code pattern.
Note that I would have preferred that this function return a list
of all available filters, but HDF5 does not support that functionality.
So this PR implements the dispatch function and implements
the following standard functions:
+ bzip2
+ zstandard
+ blosc
Specific test cases are also provided for HDF5 and NCZarr.
Over time, other specific standard filters will be defined.
## Primary Changes
* Add nc_inq_filter_avail() to netcdf-c API.
* Add standard filter implementations to test use of *nc_inq_filter_avail*.
* Bump the dispatch table version number and add to all the relevant
dispatch tables (libsrc, libsrcp, etc).
* Create a program to invoke nc_inq_filter_avail so that it is accessible
to shell scripts.
* Cleanup szip support to properly support szip
when HDF5 is disabled. This involves detecting
libsz separately from testing if HDF5 supports szip.
* Integrate shuffle and fletcher32 into the existing
filter API. This means that, for example, nc_def_var_fletcher32
is now a wrapper around nc_def_var_filter.
* Extend the Codec defaulting to allow multiple default shared libraries.
## Misc. Changes
* Modify configure.ac/CMakeLists.txt to look for the relevant
libraries implementing standard filters.
* Modify libnetcdf.settings to list available standard filters
(including deflate and szip).
* Add CMake test modules to locate libbz2 and libzstd.
* Cleanup the HDF5 memory manager function use in the plugins.
* remove unused file include//ncfilter.h
* remove tests for the HDF5 memory operations e.g. H5allocate_memory.
* Add flag to ncdump to force use of _Filter instead of _Deflate
or _Shuffle or _Fletcher32. Used for testing.
2022-03-15 02:39:37 +08:00
|
|
|
if (nc_inq_var_quantize(ncid, varid, &quantize_mode, &nsd_in))
|
|
|
|
|
ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
if (quantize_mode) ERR;
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
}
|
|
|
|
|
}
|
2021-08-26 20:37:45 +08:00
|
|
|
}
|
|
|
|
|
SUMMARIZE_ERR;
|
2021-08-30 12:25:57 +08:00
|
|
|
printf("**** testing quantization of scalars...");
|
|
|
|
|
{
|
|
|
|
|
int ncid, varid1, varid2;
|
|
|
|
|
int quantize_mode_in, nsd_in;
|
|
|
|
|
float float_data[DIM_LEN_1] = {1.1111111};
|
|
|
|
|
double double_data[DIM_LEN_1] = {1.111111111111};
|
|
|
|
|
|
|
|
|
|
/* Create a netcdf-4 file with two scalar vars. */
|
|
|
|
|
if (nc_create(FILE_NAME, NC_NETCDF4|NC_CLOBBER, &ncid)) ERR;
|
|
|
|
|
if (nc_def_var(ncid, VAR_NAME_1, NC_FLOAT, 0, NULL, &varid1)) ERR;
|
|
|
|
|
if (nc_def_var(ncid, VAR_NAME_2, NC_DOUBLE, 0, NULL, &varid2)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Turn on quantize for both vars. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Write some data. */
|
|
|
|
|
if (nc_put_var_float(ncid, varid1, float_data)) ERR;
|
|
|
|
|
if (nc_put_var_double(ncid, varid2, double_data)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Close the file. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
float float_in;
|
|
|
|
|
double double_in;
|
|
|
|
|
union FU fin;
|
|
|
|
|
int nsd_att_in;
|
|
|
|
|
/* union FU fout; */
|
|
|
|
|
union DU dfin;
|
|
|
|
|
/* union DU dfout; */
|
|
|
|
|
|
|
|
|
|
/* Open the file and check metadata. */
|
|
|
|
|
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_varid(ncid, VAR_NAME_1, &varid1)) ERR;
|
|
|
|
|
if (nc_inq_varid(ncid, VAR_NAME_2, &varid2)) ERR;
|
|
|
|
|
if (nc_inq_var_quantize(ncid, varid1, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-30 12:25:57 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_var_quantize(ncid, varid2, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-30 12:25:57 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
|
|
|
|
|
|
|
|
|
/* Each var now has an attribute describing the quantize settings. */
|
2021-10-22 02:39:39 +08:00
|
|
|
if (nc_get_att_int(ncid, 0, NC_QUANTIZE_BITGROOM_ATT_NAME, &nsd_att_in)) ERR;
|
2021-08-30 12:25:57 +08:00
|
|
|
if (nsd_att_in != NSD_3) ERR;
|
2021-10-22 02:39:39 +08:00
|
|
|
if (nc_get_att_int(ncid, 1, NC_QUANTIZE_BITGROOM_ATT_NAME, &nsd_att_in)) ERR;
|
2021-08-30 12:25:57 +08:00
|
|
|
if (nsd_att_in != NSD_3) ERR;
|
|
|
|
|
|
|
|
|
|
/* Check the data. */
|
|
|
|
|
if (nc_get_var(ncid, varid1, &float_in)) ERR;
|
|
|
|
|
if (nc_get_var(ncid, varid2, &double_in)) ERR;
|
|
|
|
|
/* fout.f = float_data[0]; */
|
|
|
|
|
fin.f = float_in;
|
|
|
|
|
/* dfout.d = double_data[0]; */
|
|
|
|
|
dfin.d = double_in;
|
|
|
|
|
/* printf ("\nfloat_data: %10f : 0x%x float_data_in: %10f : 0x%x\n", */
|
|
|
|
|
/* float_data[0], fout.u, float_data[0], fin.u); */
|
|
|
|
|
if (fin.u != 0x3f8e3000) ERR;
|
2022-02-20 06:48:08 +08:00
|
|
|
/* printf ("\ndouble_data: %15g : 0x%16llx double_data_in: %15g : 0x%llx\n", */
|
|
|
|
|
/* double_data[0], dfout.u, double_data[0], dfin.u);*/
|
2021-08-30 12:25:57 +08:00
|
|
|
if (dfin.u != 0x3ff1c60000000000) ERR;
|
|
|
|
|
|
|
|
|
|
/* Close the file again. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
SUMMARIZE_ERR;
|
2021-08-29 15:04:09 +08:00
|
|
|
printf("**** testing quantization of one value...");
|
2021-08-26 21:21:07 +08:00
|
|
|
{
|
2021-08-29 15:13:39 +08:00
|
|
|
int ncid, dimid, varid1, varid2;
|
|
|
|
|
int quantize_mode_in, nsd_in;
|
|
|
|
|
float float_data[DIM_LEN_1] = {1.1111111};
|
|
|
|
|
double double_data[DIM_LEN_1] = {1.111111111111};
|
|
|
|
|
|
|
|
|
|
/* Create a netcdf-4 file with two vars. */
|
|
|
|
|
if (nc_create(FILE_NAME, NC_NETCDF4|NC_CLOBBER, &ncid)) ERR;
|
|
|
|
|
if (nc_def_dim(ncid, DIM_NAME_1, DIM_LEN_1, &dimid)) ERR;
|
2021-09-01 16:24:28 +08:00
|
|
|
if (nc_def_var(ncid, VAR_NAME_1, NC_FLOAT, NDIM1, &dimid, &varid1)) ERR;
|
|
|
|
|
if (nc_def_var(ncid, VAR_NAME_2, NC_DOUBLE, NDIM1, &dimid, &varid2)) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
|
|
|
|
|
/* Turn on quantize for both vars. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
2021-08-30 10:50:19 +08:00
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
|
|
|
|
|
/* Write some data. */
|
|
|
|
|
if (nc_put_var_float(ncid, varid1, float_data)) ERR;
|
|
|
|
|
if (nc_put_var_double(ncid, varid2, double_data)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Close the file. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
float float_in;
|
|
|
|
|
double double_in;
|
2021-08-30 10:50:19 +08:00
|
|
|
union FU fin;
|
|
|
|
|
/* union FU fout; */
|
|
|
|
|
union DU dfin;
|
2021-08-30 12:25:57 +08:00
|
|
|
/* union DU dfout; */
|
2021-08-29 15:13:39 +08:00
|
|
|
|
|
|
|
|
/* Open the file and check metadata. */
|
|
|
|
|
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_varid(ncid,VAR_NAME_1,&varid1)) ERR;
|
|
|
|
|
if (nc_inq_varid(ncid,VAR_NAME_2,&varid2)) ERR;
|
|
|
|
|
if (nc_inq_var_quantize(ncid, varid1, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_var_quantize(ncid, varid2, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-30 10:50:19 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
|
|
|
|
|
/* Check the data. */
|
|
|
|
|
if (nc_get_var(ncid, varid1, &float_in)) ERR;
|
|
|
|
|
if (nc_get_var(ncid, varid2, &double_in)) ERR;
|
2021-08-30 10:50:19 +08:00
|
|
|
/* fout.f = float_data[0]; */
|
2021-08-29 15:13:39 +08:00
|
|
|
fin.f = float_in;
|
2021-08-30 10:50:19 +08:00
|
|
|
/* dfout.d = double_data[0]; */
|
2021-08-29 22:42:21 +08:00
|
|
|
dfin.d = double_in;
|
2021-08-30 10:50:19 +08:00
|
|
|
/* printf ("\nfloat_data: %10f : 0x%x float_data_in: %10f : 0x%x\n", */
|
|
|
|
|
/* float_data[0], fout.u, float_data[0], fin.u); */
|
2021-08-29 15:13:39 +08:00
|
|
|
if (fin.u != 0x3f8e3000) ERR;
|
2022-02-20 06:48:08 +08:00
|
|
|
/* printf ("\ndouble_data: %15g : 0x%16llx double_data_in: %15g : 0x%llx\n", */
|
2021-08-30 10:50:19 +08:00
|
|
|
/* double_data[0], dfout.u, double_data[0], dfin.u); */
|
2021-08-30 10:39:51 +08:00
|
|
|
if (dfin.u != 0x3ff1c60000000000) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
|
|
|
|
|
/* Close the file again. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
}
|
2021-08-26 21:21:07 +08:00
|
|
|
}
|
|
|
|
|
SUMMARIZE_ERR;
|
2021-08-29 15:04:09 +08:00
|
|
|
printf("**** testing more quantization values...");
|
|
|
|
|
{
|
2021-08-29 15:13:39 +08:00
|
|
|
int ncid, dimid, varid1, varid2;
|
|
|
|
|
int quantize_mode_in, nsd_in;
|
|
|
|
|
float float_data[DIM_LEN_5] = {1.11111111, 1.0, 9.99999999, 12345.67, .1234567};
|
|
|
|
|
double double_data[DIM_LEN_5] = {1.1111111, 1.0, 9.999999999, 1234567890.12345, 123456789012345.0};
|
|
|
|
|
int x;
|
|
|
|
|
|
|
|
|
|
/* Create a netcdf-4 file with two vars. */
|
|
|
|
|
if (nc_create(FILE_NAME, NC_NETCDF4|NC_CLOBBER, &ncid)) ERR;
|
|
|
|
|
if (nc_def_dim(ncid, DIM_NAME_1, DIM_LEN_5, &dimid)) ERR;
|
2021-09-01 16:24:28 +08:00
|
|
|
if (nc_def_var(ncid, VAR_NAME_1, NC_FLOAT, NDIM1, &dimid, &varid1)) ERR;
|
|
|
|
|
if (nc_def_var(ncid, VAR_NAME_2, NC_DOUBLE, NDIM1, &dimid, &varid2)) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
|
|
|
|
|
/* Turn on quantize for both vars. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
2021-08-30 10:50:19 +08:00
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
|
|
|
|
|
/* Write some data. */
|
|
|
|
|
if (nc_put_var_float(ncid, varid1, float_data)) ERR;
|
|
|
|
|
if (nc_put_var_double(ncid, varid2, double_data)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Close the file. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
float float_in[DIM_LEN_5];
|
|
|
|
|
double double_in[DIM_LEN_5];
|
|
|
|
|
union FU {
|
|
|
|
|
float f;
|
|
|
|
|
uint32_t u;
|
|
|
|
|
};
|
|
|
|
|
|
2021-08-30 10:50:19 +08:00
|
|
|
union FU fin;
|
|
|
|
|
/* union FU fout; */
|
2021-08-29 15:13:39 +08:00
|
|
|
union FU xpect[DIM_LEN_5];
|
2021-08-29 22:42:21 +08:00
|
|
|
union DU dfin;
|
2021-08-30 10:50:19 +08:00
|
|
|
/* union DU dfout; */
|
2021-08-29 22:42:21 +08:00
|
|
|
union DU double_xpect[DIM_LEN_5];
|
2021-08-29 15:13:39 +08:00
|
|
|
xpect[0].u = 0x3f8e3000;
|
|
|
|
|
xpect[1].u = 0x3f800fff;
|
|
|
|
|
xpect[2].u = 0x41200000;
|
|
|
|
|
xpect[3].u = 0x4640efff;
|
|
|
|
|
xpect[4].u = 0x3dfcd000;
|
2021-08-29 22:42:21 +08:00
|
|
|
double_xpect[0].u = 0x3ff1c60000000000;
|
|
|
|
|
double_xpect[1].u = 0x3ff001ffffffffff;
|
|
|
|
|
double_xpect[2].u = 0x4023fe0000000000;
|
|
|
|
|
double_xpect[3].u = 0x41d265ffffffffff;
|
|
|
|
|
double_xpect[4].u = 0x42dc120000000000;
|
2021-08-29 15:13:39 +08:00
|
|
|
|
|
|
|
|
/* Open the file and check metadata. */
|
|
|
|
|
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_varid(ncid,VAR_NAME_1,&varid1)) ERR;
|
|
|
|
|
if (nc_inq_varid(ncid,VAR_NAME_2,&varid2)) ERR;
|
|
|
|
|
if (nc_inq_var_quantize(ncid, varid1, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_var_quantize(ncid, varid2, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-30 10:50:19 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
|
|
|
|
|
/* Check the data. */
|
|
|
|
|
if (nc_get_var(ncid, varid1, float_in)) ERR;
|
|
|
|
|
if (nc_get_var(ncid, varid2, double_in)) ERR;
|
2021-08-30 10:50:19 +08:00
|
|
|
/* printf("\n"); */
|
2021-08-29 15:13:39 +08:00
|
|
|
for (x = 0; x < DIM_LEN_5; x++)
|
|
|
|
|
{
|
2021-08-30 10:50:19 +08:00
|
|
|
/* fout.f = float_data[x]; */
|
2021-08-29 15:13:39 +08:00
|
|
|
fin.f = float_in[x];
|
2021-08-30 10:39:51 +08:00
|
|
|
/* printf ("float_data: %10f : 0x%x float_data_in: %10f : 0x%x\n", */
|
|
|
|
|
/* float_data[x], fout.u, float_data[x], fin.u); */
|
2021-08-29 15:13:39 +08:00
|
|
|
if (fin.u != xpect[x].u) ERR;
|
2021-08-30 10:50:19 +08:00
|
|
|
/* dfout.d = double_data[x]; */
|
2021-08-29 22:42:21 +08:00
|
|
|
dfin.d = double_in[x];
|
2022-02-20 06:48:08 +08:00
|
|
|
/*printf("double_data: %15g : 0x%16llx double_data_in: %15g : 0x%16llx\n",*/
|
|
|
|
|
/* double_data[x], dfout.u, double_data[x], dfin.u);*/
|
2021-08-30 10:50:19 +08:00
|
|
|
if (dfin.u != double_xpect[x].u) ERR;
|
2021-08-29 15:13:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Close the file again. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
}
|
2021-08-29 15:04:09 +08:00
|
|
|
}
|
|
|
|
|
SUMMARIZE_ERR;
|
2021-08-30 12:34:14 +08:00
|
|
|
printf("**** testing quantization of one value with type conversion...");
|
|
|
|
|
{
|
|
|
|
|
int ncid, dimid, varid1, varid2;
|
|
|
|
|
int quantize_mode_in, nsd_in;
|
|
|
|
|
float float_data[DIM_LEN_1] = {1.1111111};
|
|
|
|
|
double double_data[DIM_LEN_1] = {1.111111111111};
|
|
|
|
|
|
|
|
|
|
/* Create a netcdf-4 file with two vars. */
|
|
|
|
|
if (nc_create(FILE_NAME, NC_NETCDF4|NC_CLOBBER, &ncid)) ERR;
|
|
|
|
|
if (nc_def_dim(ncid, DIM_NAME_1, DIM_LEN_1, &dimid)) ERR;
|
2021-09-01 16:24:28 +08:00
|
|
|
if (nc_def_var(ncid, VAR_NAME_1, NC_FLOAT, NDIM1, &dimid, &varid1)) ERR;
|
|
|
|
|
if (nc_def_var(ncid, VAR_NAME_2, NC_DOUBLE, NDIM1, &dimid, &varid2)) ERR;
|
2021-08-30 12:34:14 +08:00
|
|
|
|
|
|
|
|
/* Turn on quantize for both vars. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Write some double data to float var. */
|
|
|
|
|
if (nc_put_var_double(ncid, varid1, double_data)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Write some float data to double var. */
|
|
|
|
|
if (nc_put_var_float(ncid, varid2, float_data)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Close the file. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
float float_in;
|
|
|
|
|
double double_in;
|
|
|
|
|
union FU fin;
|
2021-08-31 20:42:30 +08:00
|
|
|
/* union FU fout; */
|
2021-08-30 12:34:14 +08:00
|
|
|
union DU dfin;
|
2021-08-31 20:42:30 +08:00
|
|
|
/* union DU dfout; */
|
2021-08-30 13:06:16 +08:00
|
|
|
int nsd_att_in;
|
2021-08-30 12:34:14 +08:00
|
|
|
|
|
|
|
|
/* Open the file and check metadata. */
|
|
|
|
|
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_varid(ncid,VAR_NAME_1,&varid1)) ERR;
|
|
|
|
|
if (nc_inq_varid(ncid,VAR_NAME_2,&varid2)) ERR;
|
|
|
|
|
if (nc_inq_var_quantize(ncid, varid1, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-30 12:34:14 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_var_quantize(ncid, varid2, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-30 12:34:14 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
|
|
|
|
|
2021-08-30 13:06:16 +08:00
|
|
|
/* Each var now has an attribute describing the quantize settings. */
|
2021-10-22 02:39:39 +08:00
|
|
|
if (nc_get_att_int(ncid, 0, NC_QUANTIZE_BITGROOM_ATT_NAME, &nsd_att_in)) ERR;
|
2021-08-30 13:06:16 +08:00
|
|
|
if (nsd_att_in != NSD_3) ERR;
|
2021-10-22 02:39:39 +08:00
|
|
|
if (nc_get_att_int(ncid, 1, NC_QUANTIZE_BITGROOM_ATT_NAME, &nsd_att_in)) ERR;
|
2021-08-30 13:06:16 +08:00
|
|
|
if (nsd_att_in != NSD_3) ERR;
|
|
|
|
|
|
2021-08-30 12:34:14 +08:00
|
|
|
/* Check the data. */
|
|
|
|
|
if (nc_get_var(ncid, varid1, &float_in)) ERR;
|
|
|
|
|
if (nc_get_var(ncid, varid2, &double_in)) ERR;
|
2021-08-31 20:42:30 +08:00
|
|
|
/* fout.f = (float)double_data[0]; */
|
2021-08-30 12:34:14 +08:00
|
|
|
fin.f = float_in;
|
2021-08-31 20:42:30 +08:00
|
|
|
/* dfout.d = float_data[0]; */
|
2021-08-30 12:34:14 +08:00
|
|
|
dfin.d = double_in;
|
2021-08-31 20:42:30 +08:00
|
|
|
/* printf ("\ndouble_data: %15g : 0x%x float_data_in: %10f : 0x%x\n", */
|
|
|
|
|
/* double_data[0], fout.u, float_in, fin.u); */
|
|
|
|
|
if (fin.u != 0x3f8e3000) ERR;
|
|
|
|
|
/* printf ("\nfloat_data: %15g : 0x%16lx double_data_in: %15g : 0x%lx\n", */
|
|
|
|
|
/* float_data[0], dfout.u, double_in, dfin.u); */
|
|
|
|
|
if (dfin.u != 0x3ff1c60000000000) ERR;
|
|
|
|
|
|
|
|
|
|
/* Close the file again. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
SUMMARIZE_ERR;
|
|
|
|
|
printf("**** testing more quantization values with type conversion...");
|
|
|
|
|
{
|
|
|
|
|
int ncid, dimid, varid1, varid2;
|
|
|
|
|
int quantize_mode_in, nsd_in;
|
|
|
|
|
float float_data[DIM_LEN_5] = {1.11111111, 1.0, 9.99999999, 12345.67, .1234567};
|
|
|
|
|
double double_data[DIM_LEN_5] = {1.1111111, 1.0, 9.999999999, 1234567890.12345, 123456789012345.0};
|
|
|
|
|
int x;
|
|
|
|
|
|
|
|
|
|
/* Create a netcdf-4 file with two vars. */
|
|
|
|
|
if (nc_create(FILE_NAME, NC_NETCDF4|NC_CLOBBER, &ncid)) ERR;
|
|
|
|
|
if (nc_def_dim(ncid, DIM_NAME_1, DIM_LEN_5, &dimid)) ERR;
|
2021-09-01 16:24:28 +08:00
|
|
|
if (nc_def_var(ncid, VAR_NAME_1, NC_FLOAT, NDIM1, &dimid, &varid1)) ERR;
|
|
|
|
|
if (nc_def_var(ncid, VAR_NAME_2, NC_DOUBLE, NDIM1, &dimid, &varid2)) ERR;
|
2021-08-31 20:42:30 +08:00
|
|
|
|
|
|
|
|
/* Turn on quantize for both vars. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Write some data. */
|
|
|
|
|
if (nc_put_var_double(ncid, varid1, double_data)) ERR;
|
|
|
|
|
if (nc_put_var_float(ncid, varid2, float_data)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Close the file. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
float float_in[DIM_LEN_5];
|
|
|
|
|
double double_in[DIM_LEN_5];
|
|
|
|
|
union FU {
|
|
|
|
|
float f;
|
|
|
|
|
uint32_t u;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
union FU fin;
|
|
|
|
|
/* union FU fout; */
|
|
|
|
|
union FU xpect[DIM_LEN_5];
|
|
|
|
|
union DU dfin;
|
2022-04-26 19:31:07 +08:00
|
|
|
/* union DU dfout; */
|
2021-08-31 20:42:30 +08:00
|
|
|
union DU double_xpect[DIM_LEN_5];
|
|
|
|
|
xpect[0].u = 0x3f8e3000;
|
|
|
|
|
xpect[1].u = 0x3f800fff;
|
|
|
|
|
xpect[2].u = 0x41200000;
|
|
|
|
|
xpect[3].u = 0x4e932fff;
|
|
|
|
|
xpect[4].u = 0x56e09000;
|
|
|
|
|
double_xpect[0].u = 0x3ff1c60000000000;
|
|
|
|
|
double_xpect[1].u = 0x3ff001ffffffffff;
|
|
|
|
|
double_xpect[2].u = 0x4024000000000000;
|
|
|
|
|
double_xpect[3].u = 0x40c81dffffffffff;
|
|
|
|
|
double_xpect[4].u = 0x3fbf9a0000000000;
|
|
|
|
|
|
|
|
|
|
/* Open the file and check metadata. */
|
|
|
|
|
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_varid(ncid,VAR_NAME_1,&varid1)) ERR;
|
|
|
|
|
if (nc_inq_varid(ncid,VAR_NAME_2,&varid2)) ERR;
|
|
|
|
|
if (nc_inq_var_quantize(ncid, varid1, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-31 20:42:30 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_var_quantize(ncid, varid2, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-31 20:42:30 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
2021-08-31 20:59:59 +08:00
|
|
|
|
|
|
|
|
/* Check the data. */
|
|
|
|
|
if (nc_get_var(ncid, varid1, float_in)) ERR;
|
|
|
|
|
if (nc_get_var(ncid, varid2, double_in)) ERR;
|
|
|
|
|
/* printf("\n"); */
|
|
|
|
|
for (x = 0; x < DIM_LEN_5; x++)
|
|
|
|
|
{
|
|
|
|
|
/* fout.f = float_data[x]; */
|
|
|
|
|
fin.f = float_in[x];
|
|
|
|
|
/* printf ("float_data: %10f : 0x%x float_data_in: %10f : 0x%x\n", */
|
|
|
|
|
/* float_data[x], fout.u, float_data[x], fin.u); */
|
|
|
|
|
if (fin.u != xpect[x].u) ERR;
|
|
|
|
|
/* dfout.d = double_data[x]; */
|
|
|
|
|
dfin.d = double_in[x];
|
2022-02-20 06:48:08 +08:00
|
|
|
/* printf("double_data: %15g : 0x%16llx double_data_in: %15g : 0x%16llx\n",*/
|
|
|
|
|
/* double_data[x], dfout.u, double_data[x], dfin.u);*/
|
2021-08-31 20:59:59 +08:00
|
|
|
if (dfin.u != double_xpect[x].u) ERR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Close the file again. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
SUMMARIZE_ERR;
|
|
|
|
|
printf("**** testing more quantization values with default fill values...");
|
2021-08-31 21:12:46 +08:00
|
|
|
{
|
|
|
|
|
int ncid, dimid, varid1, varid2;
|
|
|
|
|
int quantize_mode_in, nsd_in;
|
|
|
|
|
float float_data[DIM_LEN_5] = {1.11111111, NC_FILL_FLOAT, 9.99999999, 12345.67, NC_FILL_FLOAT};
|
|
|
|
|
double double_data[DIM_LEN_5] = {1.1111111, NC_FILL_DOUBLE, 9.999999999, 1234567890.12345, NC_FILL_DOUBLE};
|
|
|
|
|
int x;
|
|
|
|
|
|
|
|
|
|
/* Create a netcdf-4 file with two vars. */
|
|
|
|
|
if (nc_create(FILE_NAME, NC_NETCDF4|NC_CLOBBER, &ncid)) ERR;
|
|
|
|
|
if (nc_def_dim(ncid, DIM_NAME_1, DIM_LEN_5, &dimid)) ERR;
|
2021-09-01 16:24:28 +08:00
|
|
|
if (nc_def_var(ncid, VAR_NAME_1, NC_FLOAT, NDIM1, &dimid, &varid1)) ERR;
|
|
|
|
|
if (nc_def_var(ncid, VAR_NAME_2, NC_DOUBLE, NDIM1, &dimid, &varid2)) ERR;
|
2021-08-31 21:12:46 +08:00
|
|
|
|
|
|
|
|
/* Turn on quantize for both vars. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Write some data. */
|
|
|
|
|
if (nc_put_var_float(ncid, varid1, float_data)) ERR;
|
|
|
|
|
if (nc_put_var_double(ncid, varid2, double_data)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Close the file. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
float float_in[DIM_LEN_5];
|
|
|
|
|
double double_in[DIM_LEN_5];
|
|
|
|
|
union FU {
|
|
|
|
|
float f;
|
|
|
|
|
uint32_t u;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
union FU fin;
|
|
|
|
|
/* union FU fout; */
|
|
|
|
|
union FU xpect[DIM_LEN_5];
|
|
|
|
|
union DU dfin;
|
|
|
|
|
/* union DU dfout; */
|
|
|
|
|
union DU double_xpect[DIM_LEN_5];
|
|
|
|
|
xpect[0].u = 0x3f8e3000;
|
|
|
|
|
xpect[1].u = 0x7cf00000;
|
|
|
|
|
xpect[2].u = 0x41200000;
|
|
|
|
|
xpect[3].u = 0x4640efff;
|
|
|
|
|
xpect[4].u = 0x7cf00000;
|
|
|
|
|
double_xpect[0].u = 0x3ff1c60000000000;
|
|
|
|
|
double_xpect[1].u = 0x479e000000000000;
|
|
|
|
|
double_xpect[2].u = 0x4023fe0000000000;
|
|
|
|
|
double_xpect[3].u = 0x41d265ffffffffff;
|
|
|
|
|
double_xpect[4].u = 0x479e000000000000;
|
|
|
|
|
|
|
|
|
|
/* Open the file and check metadata. */
|
|
|
|
|
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_varid(ncid,VAR_NAME_1,&varid1)) ERR;
|
|
|
|
|
if (nc_inq_varid(ncid,VAR_NAME_2,&varid2)) ERR;
|
|
|
|
|
if (nc_inq_var_quantize(ncid, varid1, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-31 21:12:46 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_var_quantize(ncid, varid2, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-31 21:12:46 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
|
|
|
|
|
|
|
|
|
/* Check the data. */
|
|
|
|
|
if (nc_get_var(ncid, varid1, float_in)) ERR;
|
|
|
|
|
if (nc_get_var(ncid, varid2, double_in)) ERR;
|
|
|
|
|
/* printf("\n"); */
|
|
|
|
|
for (x = 0; x < DIM_LEN_5; x++)
|
|
|
|
|
{
|
|
|
|
|
/* fout.f = float_data[x]; */
|
|
|
|
|
fin.f = float_in[x];
|
|
|
|
|
/* printf ("float_data: %10f : 0x%x float_data_in: %10f : 0x%x\n", */
|
|
|
|
|
/* float_data[x], fout.u, float_data[x], fin.u); */
|
|
|
|
|
if (fin.u != xpect[x].u) ERR;
|
|
|
|
|
/* dfout.d = double_data[x]; */
|
|
|
|
|
dfin.d = double_in[x];
|
|
|
|
|
/* printf("double_data: %15g : 0x%16lx double_data_in: %15g : 0x%16lx\n", */
|
|
|
|
|
/* double_data[x], dfout.u, double_data[x], dfin.u); */
|
|
|
|
|
if (dfin.u != double_xpect[x].u) ERR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Close the file again. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
SUMMARIZE_ERR;
|
|
|
|
|
printf("**** testing more quantization values with custom fill values...");
|
2021-08-31 20:59:59 +08:00
|
|
|
{
|
2021-08-31 21:10:54 +08:00
|
|
|
#define CUSTOM_FILL_FLOAT 99.99999
|
|
|
|
|
#define CUSTOM_FILL_DOUBLE -99999.99999
|
2021-08-31 20:59:59 +08:00
|
|
|
int ncid, dimid, varid1, varid2;
|
|
|
|
|
int quantize_mode_in, nsd_in;
|
2021-08-31 21:10:54 +08:00
|
|
|
float float_data[DIM_LEN_5] = {1.11111111, CUSTOM_FILL_FLOAT, 9.99999999, 12345.67, CUSTOM_FILL_FLOAT};
|
|
|
|
|
double double_data[DIM_LEN_5] = {1.1111111, CUSTOM_FILL_DOUBLE, 9.999999999, 1234567890.12345, CUSTOM_FILL_DOUBLE};
|
|
|
|
|
float custom_fill_float = CUSTOM_FILL_FLOAT;
|
|
|
|
|
double custom_fill_double = CUSTOM_FILL_DOUBLE;
|
2021-08-31 20:59:59 +08:00
|
|
|
int x;
|
|
|
|
|
|
|
|
|
|
/* Create a netcdf-4 file with two vars. */
|
|
|
|
|
if (nc_create(FILE_NAME, NC_NETCDF4|NC_CLOBBER, &ncid)) ERR;
|
|
|
|
|
if (nc_def_dim(ncid, DIM_NAME_1, DIM_LEN_5, &dimid)) ERR;
|
2021-09-01 16:24:28 +08:00
|
|
|
if (nc_def_var(ncid, VAR_NAME_1, NC_FLOAT, NDIM1, &dimid, &varid1)) ERR;
|
2021-08-31 21:10:54 +08:00
|
|
|
if (nc_put_att_float(ncid, varid1, _FillValue, NC_FLOAT, 1, &custom_fill_float)) ERR;
|
2021-09-01 16:24:28 +08:00
|
|
|
if (nc_def_var(ncid, VAR_NAME_2, NC_DOUBLE, NDIM1, &dimid, &varid2)) ERR;
|
2021-08-31 21:10:54 +08:00
|
|
|
if (nc_put_att_double(ncid, varid2, _FillValue, NC_DOUBLE, 1, &custom_fill_double)) ERR;
|
2021-08-31 20:59:59 +08:00
|
|
|
|
|
|
|
|
/* Turn on quantize for both vars. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Write some data. */
|
|
|
|
|
if (nc_put_var_float(ncid, varid1, float_data)) ERR;
|
|
|
|
|
if (nc_put_var_double(ncid, varid2, double_data)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Close the file. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
float float_in[DIM_LEN_5];
|
|
|
|
|
double double_in[DIM_LEN_5];
|
|
|
|
|
union FU {
|
|
|
|
|
float f;
|
|
|
|
|
uint32_t u;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
union FU fin;
|
|
|
|
|
/* union FU fout; */
|
|
|
|
|
union FU xpect[DIM_LEN_5];
|
|
|
|
|
union DU dfin;
|
|
|
|
|
/* union DU dfout; */
|
|
|
|
|
union DU double_xpect[DIM_LEN_5];
|
|
|
|
|
xpect[0].u = 0x3f8e3000;
|
2021-08-31 21:10:54 +08:00
|
|
|
xpect[1].u = 0x42c7ffff;
|
2021-08-31 20:59:59 +08:00
|
|
|
xpect[2].u = 0x41200000;
|
|
|
|
|
xpect[3].u = 0x4640efff;
|
2021-08-31 21:10:54 +08:00
|
|
|
xpect[4].u = 0x42c7ffff;
|
2021-08-31 20:59:59 +08:00
|
|
|
double_xpect[0].u = 0x3ff1c60000000000;
|
2021-08-31 21:10:54 +08:00
|
|
|
double_xpect[1].u = 0xc0f869fffff583a5;
|
2021-08-31 20:59:59 +08:00
|
|
|
double_xpect[2].u = 0x4023fe0000000000;
|
|
|
|
|
double_xpect[3].u = 0x41d265ffffffffff;
|
2021-08-31 21:10:54 +08:00
|
|
|
double_xpect[4].u = 0xc0f869fffff583a5;
|
2021-08-31 20:59:59 +08:00
|
|
|
|
|
|
|
|
/* Open the file and check metadata. */
|
|
|
|
|
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_varid(ncid,VAR_NAME_1,&varid1)) ERR;
|
|
|
|
|
if (nc_inq_varid(ncid,VAR_NAME_2,&varid2)) ERR;
|
|
|
|
|
if (nc_inq_var_quantize(ncid, varid1, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-31 20:59:59 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_var_quantize(ncid, varid2, &quantize_mode_in, &nsd_in)) ERR;
|
2021-08-31 20:59:59 +08:00
|
|
|
if (quantize_mode_in != NC_QUANTIZE_BITGROOM || nsd_in != NSD_3) ERR;
|
2021-08-31 20:42:30 +08:00
|
|
|
|
|
|
|
|
/* Check the data. */
|
|
|
|
|
if (nc_get_var(ncid, varid1, float_in)) ERR;
|
|
|
|
|
if (nc_get_var(ncid, varid2, double_in)) ERR;
|
|
|
|
|
/* printf("\n"); */
|
|
|
|
|
for (x = 0; x < DIM_LEN_5; x++)
|
|
|
|
|
{
|
|
|
|
|
/* fout.f = float_data[x]; */
|
|
|
|
|
fin.f = float_in[x];
|
|
|
|
|
/* printf ("float_data: %10f : 0x%x float_data_in: %10f : 0x%x\n", */
|
|
|
|
|
/* float_data[x], fout.u, float_data[x], fin.u); */
|
|
|
|
|
if (fin.u != xpect[x].u) ERR;
|
|
|
|
|
/* dfout.d = double_data[x]; */
|
|
|
|
|
dfin.d = double_in[x];
|
|
|
|
|
/* printf("double_data: %15g : 0x%16lx double_data_in: %15g : 0x%16lx\n", */
|
|
|
|
|
/* double_data[x], dfout.u, double_data[x], dfin.u); */
|
|
|
|
|
if (dfin.u != double_xpect[x].u) ERR;
|
|
|
|
|
}
|
2021-08-30 12:34:14 +08:00
|
|
|
|
|
|
|
|
/* Close the file again. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
SUMMARIZE_ERR;
|
2021-09-01 16:24:28 +08:00
|
|
|
printf("*** Checking BitGroom values with type conversion between ints and floats...");
|
|
|
|
|
{
|
|
|
|
|
int ncid;
|
|
|
|
|
int dimid;
|
|
|
|
|
int varid1, varid2;
|
|
|
|
|
unsigned char uc = 99;
|
|
|
|
|
signed char sc = -99;
|
|
|
|
|
unsigned short us = 9999;
|
|
|
|
|
signed short ss = -9999;
|
|
|
|
|
unsigned int ui = 9999999;
|
|
|
|
|
signed int si = -9999999;
|
|
|
|
|
unsigned long long int ull = 999999999;
|
|
|
|
|
signed long long int sll = -999999999;
|
|
|
|
|
size_t index;
|
|
|
|
|
|
|
|
|
|
/* Create file. */
|
|
|
|
|
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Create dims. */
|
|
|
|
|
if (nc_def_dim(ncid, X_NAME, DIM_LEN_8, &dimid)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Create the variables. */
|
|
|
|
|
if (nc_def_var(ncid, VAR_NAME, NC_FLOAT, NDIM1, &dimid, &varid1)) ERR;
|
|
|
|
|
if (nc_def_var(ncid, VAR_NAME_2, NC_DOUBLE, NDIM1, &dimid, &varid2)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Set up quantization. */
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
2021-08-26 21:21:07 +08:00
|
|
|
|
2021-09-01 16:24:28 +08:00
|
|
|
/* Write data. */
|
|
|
|
|
index = 0;
|
|
|
|
|
if (nc_put_var1_uchar(ncid, varid1, &index, &uc)) ERR;
|
|
|
|
|
if (nc_put_var1_uchar(ncid, varid2, &index, &uc)) ERR;
|
|
|
|
|
index = 1;
|
|
|
|
|
if (nc_put_var1_schar(ncid, varid1, &index, &sc)) ERR;
|
|
|
|
|
if (nc_put_var1_schar(ncid, varid2, &index, &sc)) ERR;
|
|
|
|
|
index = 2;
|
|
|
|
|
if (nc_put_var1_ushort(ncid, varid1, &index, &us)) ERR;
|
|
|
|
|
if (nc_put_var1_ushort(ncid, varid2, &index, &us)) ERR;
|
|
|
|
|
index = 3;
|
|
|
|
|
if (nc_put_var1_short(ncid, varid1, &index, &ss)) ERR;
|
|
|
|
|
if (nc_put_var1_short(ncid, varid2, &index, &ss)) ERR;
|
|
|
|
|
index = 4;
|
|
|
|
|
if (nc_put_var1_uint(ncid, varid1, &index, &ui)) ERR;
|
|
|
|
|
if (nc_put_var1_uint(ncid, varid2, &index, &ui)) ERR;
|
|
|
|
|
index = 5;
|
|
|
|
|
if (nc_put_var1_int(ncid, varid1, &index, &si)) ERR;
|
|
|
|
|
if (nc_put_var1_int(ncid, varid2, &index, &si)) ERR;
|
|
|
|
|
index = 6;
|
|
|
|
|
if (nc_put_var1_ulonglong(ncid, varid1, &index, &ull)) ERR;
|
|
|
|
|
if (nc_put_var1_ulonglong(ncid, varid2, &index, &ull)) ERR;
|
|
|
|
|
index = 7;
|
|
|
|
|
if (nc_put_var1_longlong(ncid, varid1, &index, &sll)) ERR;
|
|
|
|
|
if (nc_put_var1_longlong(ncid, varid2, &index, &sll)) ERR;
|
2021-08-26 20:37:45 +08:00
|
|
|
|
2021-09-01 16:24:28 +08:00
|
|
|
/* Close the file. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
2021-08-26 20:37:45 +08:00
|
|
|
|
2021-09-01 16:24:28 +08:00
|
|
|
{
|
|
|
|
|
float float_data_in[DIM_LEN_8];
|
|
|
|
|
double double_data_in[DIM_LEN_8];
|
|
|
|
|
int x;
|
|
|
|
|
|
|
|
|
|
/* Now reopen the file and check. */
|
|
|
|
|
if (nc_open(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_varid(ncid,VAR_NAME,&varid1)) ERR;
|
|
|
|
|
if (nc_inq_varid(ncid,VAR_NAME_2,&varid2)) ERR;
|
2021-09-01 16:24:28 +08:00
|
|
|
|
|
|
|
|
/* Read the data. */
|
|
|
|
|
if (nc_get_var_float(ncid, varid1, float_data_in)) ERR;
|
|
|
|
|
if (nc_get_var_double(ncid, varid2, double_data_in)) ERR;
|
|
|
|
|
|
|
|
|
|
union FU xpect[DIM_LEN_8];
|
|
|
|
|
union DU double_xpect[DIM_LEN_8];
|
2021-09-02 22:18:27 +08:00
|
|
|
/* This test comes up with different answers to this than
|
|
|
|
|
* the corresponding bitgroom filter test, but that's
|
|
|
|
|
* OK. In netcdf-c quantization is applied as the data are
|
|
|
|
|
* written by the user, but in HDF5 filters, the bitgroom
|
|
|
|
|
* filter is applied to all data values as they are
|
|
|
|
|
* written to disk. See
|
|
|
|
|
* https://github.com/ccr/ccr/issues/194 for a full
|
|
|
|
|
* explanation. */
|
2021-09-01 16:24:28 +08:00
|
|
|
xpect[0].u = 0x42c60000;
|
2021-09-02 22:18:27 +08:00
|
|
|
xpect[1].u = 0xc2c60000;
|
2021-09-01 16:24:28 +08:00
|
|
|
xpect[2].u = 0x461c3000;
|
2021-09-02 22:18:27 +08:00
|
|
|
xpect[3].u = 0xc61c3000;
|
2021-09-01 16:24:28 +08:00
|
|
|
xpect[4].u = 0x4b189000;
|
2021-09-02 22:18:27 +08:00
|
|
|
xpect[5].u = 0xcb189000;
|
|
|
|
|
xpect[6].u = 0x4e6e6b28;
|
|
|
|
|
xpect[6].u = 0x4e6e6000;
|
|
|
|
|
xpect[7].u = 0xce6e6000;
|
2021-09-01 16:24:28 +08:00
|
|
|
double_xpect[0].u = 0x4058c00000000000;
|
2021-09-02 22:18:27 +08:00
|
|
|
double_xpect[1].u = 0xc058c00000000000;
|
2021-09-01 16:24:28 +08:00
|
|
|
double_xpect[2].u = 0x40c3860000000000;
|
2021-09-02 22:18:27 +08:00
|
|
|
double_xpect[3].u = 0xc0c3860000000000;
|
2021-09-01 16:24:28 +08:00
|
|
|
double_xpect[4].u = 0x4163120000000000;
|
2021-09-02 22:18:27 +08:00
|
|
|
double_xpect[5].u = 0xc163120000000000;
|
2021-09-01 16:24:28 +08:00
|
|
|
double_xpect[6].u = 0x41cdcc0000000000;
|
2021-09-02 22:18:27 +08:00
|
|
|
double_xpect[7].u = 0xc1cdcc0000000000;
|
2021-09-01 16:24:28 +08:00
|
|
|
|
|
|
|
|
for (x = 0; x < DIM_LEN_8; x++)
|
|
|
|
|
{
|
|
|
|
|
union FU fin;
|
|
|
|
|
union DU dfin;
|
|
|
|
|
fin.f = float_data_in[x];
|
|
|
|
|
dfin.d = double_data_in[x];
|
2021-09-02 22:18:27 +08:00
|
|
|
/* printf ("%d float_data_in : %08.8f : 0x%x expected %08.8f : 0x%x\n", */
|
|
|
|
|
/* x, float_data_in[x], fin.u, xpect[x].f, xpect[x].u); */
|
2022-02-20 06:48:08 +08:00
|
|
|
/* printf ("%d double_data_in : %15g : 0x%llx expected %15g : 0x%llx\n",*/
|
|
|
|
|
/* x, double_data_in[x], dfin.u, double_xpect[x].d, double_xpect[x].u);*/
|
2021-09-02 22:18:27 +08:00
|
|
|
if (fin.u != xpect[x].u)
|
|
|
|
|
ERR;
|
|
|
|
|
if (dfin.u != double_xpect[x].u)
|
|
|
|
|
ERR;
|
2021-09-01 16:24:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Close the file. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
SUMMARIZE_ERR;
|
2021-11-26 21:29:35 +08:00
|
|
|
printf("*** Nice, simple example of using BitGroom plus zlib...");
|
|
|
|
|
{
|
2021-11-26 21:35:18 +08:00
|
|
|
#define DIM_LEN_SIMPLE 100
|
2021-11-26 21:29:35 +08:00
|
|
|
#define EPSILON .1
|
|
|
|
|
int ncid;
|
|
|
|
|
int dimid;
|
|
|
|
|
int varid1, varid2;
|
|
|
|
|
float *float_data;
|
|
|
|
|
double *double_data;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* Set up some data to write. */
|
|
|
|
|
if (!(float_data = malloc(DIM_LEN_SIMPLE * sizeof(float))))
|
|
|
|
|
ERR;
|
|
|
|
|
if (!(double_data = malloc(DIM_LEN_SIMPLE * sizeof(double))))
|
|
|
|
|
ERR;
|
|
|
|
|
for (i = 0; i < DIM_LEN_SIMPLE; i++)
|
|
|
|
|
{
|
|
|
|
|
float_data[i] = 1.5 * i;
|
|
|
|
|
double_data[i] = 1.5 * i;
|
|
|
|
|
}
|
|
|
|
|
|
2021-11-26 21:35:18 +08:00
|
|
|
/* Create the file. */
|
2021-11-26 21:29:35 +08:00
|
|
|
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
|
|
|
|
|
|
2021-11-26 21:35:18 +08:00
|
|
|
/* Add one dimension. */
|
2021-11-26 21:29:35 +08:00
|
|
|
if (nc_def_dim(ncid, "dim1", DIM_LEN_SIMPLE, &dimid)) ERR;
|
|
|
|
|
|
2021-11-26 21:35:18 +08:00
|
|
|
/* Create two variables, one float, one double. Quantization
|
|
|
|
|
* may only be applied to floating point data. */
|
2021-11-26 21:29:35 +08:00
|
|
|
if (nc_def_var(ncid, "var1", NC_FLOAT, NDIM1, &dimid, &varid1)) ERR;
|
|
|
|
|
if (nc_def_var(ncid, "var2", NC_DOUBLE, NDIM1, &dimid, &varid2)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Set up quantization. This will not make the data any
|
2021-11-26 21:35:18 +08:00
|
|
|
* smaller, unless compression is also turned on. In this
|
|
|
|
|
* case, we will set 3 significant digits. */
|
2021-11-26 21:29:35 +08:00
|
|
|
if (nc_def_var_quantize(ncid, varid1, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
if (nc_def_var_quantize(ncid, varid2, NC_QUANTIZE_BITGROOM, NSD_3)) ERR;
|
|
|
|
|
|
2022-01-25 06:22:24 +08:00
|
|
|
#ifdef TESTNCZARR
|
|
|
|
|
#ifdef ENABLE_NCZARR_FILTERS
|
2021-11-26 21:29:35 +08:00
|
|
|
/* Set up zlib compression. This will work better because the
|
2021-11-26 21:35:18 +08:00
|
|
|
* data are quantized, yielding a smaller output file. We will
|
|
|
|
|
* set compression level to 1, which is usually the best
|
|
|
|
|
* choice. */
|
2021-11-26 21:29:35 +08:00
|
|
|
if (nc_def_var_deflate(ncid, varid1, 0, 1, 1)) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
#endif
|
|
|
|
|
#endif
|
2021-11-26 21:35:18 +08:00
|
|
|
/* Write the data. */
|
2021-11-26 21:29:35 +08:00
|
|
|
if (nc_put_var_float(ncid, varid1, float_data)) ERR;
|
|
|
|
|
if (nc_put_var_double(ncid, varid2, double_data)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Close the file. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
|
|
|
|
|
/* Check the resulting file for correctness. */
|
|
|
|
|
{
|
|
|
|
|
float float_data_in[DIM_LEN_SIMPLE];
|
|
|
|
|
double double_data_in[DIM_LEN_SIMPLE];
|
|
|
|
|
|
|
|
|
|
/* Now reopen the file and check. */
|
|
|
|
|
if (nc_open(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
|
2022-01-25 06:22:24 +08:00
|
|
|
if (nc_inq_varid(ncid,"var1",&varid1)) ERR;
|
|
|
|
|
if (nc_inq_varid(ncid,"var2",&varid2)) ERR;
|
2021-11-26 21:29:35 +08:00
|
|
|
|
|
|
|
|
/* Read the data. */
|
|
|
|
|
if (nc_get_var_float(ncid, varid1, float_data_in)) ERR;
|
|
|
|
|
if (nc_get_var_double(ncid, varid2, double_data_in)) ERR;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < DIM_LEN_SIMPLE; i++)
|
|
|
|
|
{
|
2022-02-20 06:48:08 +08:00
|
|
|
if (fabs(float_data_in[i] - float_data[i]) > EPSILON)
|
2021-11-26 21:29:35 +08:00
|
|
|
ERR;
|
2022-02-20 06:48:08 +08:00
|
|
|
if (fabs(double_data_in[i] - double_data[i]) > EPSILON)
|
2021-11-26 21:29:35 +08:00
|
|
|
ERR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Close the file. */
|
|
|
|
|
if (nc_close(ncid)) ERR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Free resources. */
|
|
|
|
|
free(float_data);
|
|
|
|
|
free(double_data);
|
|
|
|
|
}
|
|
|
|
|
SUMMARIZE_ERR;
|
2021-09-01 16:24:28 +08:00
|
|
|
FINAL_RESULTS;
|
2021-08-24 14:45:38 +08:00
|
|
|
}
|
