//
// vdfcreate code snippet that demonstrates creating a simple .vdf file
// with multiple time steps and 3d variables, both with uniform sampling
//
{

	// Initialize VDC object. Data will be stored in NetCDF files.
	// n.b. no current plans for supporting other file formats
	//
	VDC vdc(VDC::NETCDF4);

	// Open the VDC master file for writing. Have to specify how
	// many compression ratios we will have
	//
	status = vdc.Initialize(masterpath, "w");

	// Set up compression parameters. We will use the same ones for all
	// variables. Ditto for boundary periodicity
	//
	vdc.SetCompressionBlock(opt.bs, opt.wname, opt.wmode, opt.cratios());
	vdc.SetPeriodicBoundary(opt.periodic);

	// All 3D variables have the same dimensions, named "x", "y", and "z", 
	// plus time, "t"
	//
	vector <string> dimnames;
	dimnames.push_back("x");
	dimnames.push_back("y");
	dimnames.push_back("z");
	dimnames.push_back("t");

	// Dimension lenths.
	//
	vector <size_t> dimlens;
	dimlens.push_back(opt.dims[0]);
	dimlens.push_back(opt.dims[1]);
	dimlens.push_back(opt.dims[2]);
	dimlens.push_back(opt.numts);

	// Identify the axis for each dimension
	//
	vector <enum> axes;
	axes.push_back(VDC:X);
	axes.push_back(VDC:Y);
	axes.push_back(VDC:Z);
	axes.push_back(VDC:T);

	// Each dimension in the VDC has a 1D coordinate variable of the same
	// name. 
	//
	vector <string> coordnames;
	coordnames.push_back(dimnames[0]);
	coordnames.push_back(dimnames[1]);
	coordnames.push_back(dimnames[2]);
	coordnames.push_back(dimnames[3]);


	// Define dimensions and 1D coordinate variable associated with the 
	// dimension. The DefineDimension() method both defines a dimension
	// name and length, as well as a 1D coordinate variable, of the same
	// name, with uniform sampling.
	// 
	// Here we only have 4: x, y, z, and time (t)
	//
	for (int i=0; i<dimnames.size(); i++) {
		vdc.DefineDimension(dimnames[i], dimlens[i], axes[i]);
	}

	// No longer need to expliclity define the 1D coordinate variables 
	// associated with each dimension: DefineDimension() automatically does
	// this for us.
	//
	//#for (int i=0; i<dimnames.size(); i++) {
	//#	vdc.DefineCoordVarUniform(
	//#		coordnames[i], dimnames[i], "", axes[i], VDC::FLOAT32, false
	//#	);
	//#}

	// Now define each of the 3D variables. We would need to do similar
	// thing for each 2D variable...
	// Again no units, but this time the variables are compressed
	// The vdc.Set* methods above determine the compression, block size, etc.
	//
	for (int i=0; i<opt.vars3d.size(); i++) {
		DefineDataVar(
			opt.vars3d[i], dimnames, coordnames, "", VDC::FLOAT32, true
		);
	}

	// We're done defining the master file
	//
	vdc.EndDefine();

	// Since the coordinate variables are time-invariant, and are calculated
	// based on args to vdfcreate,  go ahead and calculate and write them 
	// out now.  
	//
	size_t nx = dimmap["x"];
	float deltax = (opt.extents[3] - opt.extents[0]) / (nx-1);
	for (int i=0; i<dimmap["x"]; i++) {
		xcoords[i] = opt.extents[0] + i * deltax;
	}

	size_t ny = dimmap["y"];
	float deltay = (opt.extents[4] - opt.extents[1]) / (ny-1);
	for (int i=0; i<dimmap["y"]; i++) {
		ycoords[i] = opt.extents[1] + i * deltay;
	}
	size_t nz = dimmap["z"];
	float deltaz = (opt.extents[5] - opt.extents[2]) / (nz-1);
	for (int i=0; i<dimmap["z"]; i++) {
		zcoords[i] = opt.extents[2] + i * deltaz;
	}

	size_t nt = dimmap["t"];
	float deltat = opt.deltat
	for (int i=0; i<dimmap["t"]; i++) {
		tcoords[i] = opt.startt + i * deltat;
	}


	// Now we write coord vars using the simple "PutVar" method
	//
	vdc.PutVar(coordnames[0], xcoords);
	vdc.PutVar(coordnames[1], ycoords);
	vdc.PutVar(coordnames[2], zcoords);
	vdc.PutVar(coordnames[3], tcoords);
	
}