NCDataSet* NCDataSetBuilder::createDataSet() {
returned = true;
if (RepastProcess::instance()->rank() == 0) {
NcFile* ncfile = new NcFile(dataSet->file_.c_str(), NcFile::Replace, NULL, 0, NcFile::Offset64Bits);
NcDim* runDim = ncfile->add_dim("run", 1);
NcDim* tickDim = ncfile->add_dim("tick");
ncfile->add_var("tick", ncDouble, tickDim);
for (size_t i = 0; i < dataSet->dataSources.size(); i++) {
NCDataSource* ds = dataSet->dataSources[i];
ncfile->add_var(ds->name().c_str(), ds->ncType(), tickDim, runDim);
}
dataSet->ncfile = ncfile;
}
return dataSet;
}
boost::function<void ()> Grid_LonLat::netcdf_define(NcFile &nc, std::string const &vname) const
{
auto parent = Grid::netcdf_define(nc, vname);
NcDim *lonbDim = nc.add_dim((vname + ".lon_boundaries.length").c_str(),
this->lonb.size());
NcVar *lonb_var = nc.add_var((vname + ".lon_boundaries").c_str(),
ncDouble, lonbDim);
NcDim *latbDim = nc.add_dim((vname + ".lat_boundaries.length").c_str(),
this->latb.size());
NcVar *latb_var = nc.add_var((vname + ".lat_boundaries").c_str(),
ncDouble, latbDim);
NcVar *info_var = nc.get_var((vname + ".info").c_str());
info_var->add_att("north_pole_cap", north_pole ? 1 : 0);
info_var->add_att("south_pole_cap", south_pole ? 1 : 0);
info_var->add_att("points_in_side", points_in_side);
info_var->add_att("nlon", nlon());
info_var->add_att("nlat", nlat());
return boost::bind(&Grid_LonLat_netcdf_write, parent, &nc, this, vname);
}
boost::function<void()> zd11_c::netcdf_define(NcFile &nc, std::string const &vname)
{
auto oneDim = giss::get_or_add_dim(nc, "one", 1);
auto infoVar = nc.add_var((vname + ".info").c_str(), ncDouble, oneDim);
infoVar->add_att("m", this->m);
infoVar->add_att("n", this->n);
auto neDim = nc.add_dim((vname + ".ne").c_str(), this->ne);
nc.add_var((vname + ".row").c_str(), ncInt, neDim);
nc.add_var((vname + ".col").c_str(), ncInt, neDim);
nc.add_var((vname + ".val").c_str(), ncDouble, neDim);
return boost::bind(&netcdf_write, this, &nc, vname);
}
boost::function<void ()> netcdf_define(
NcFile &nc,
std::string const &vname,
blitz::Array<T,rank> const &val,
std::vector<NcDim *> const &ddims = {})
{
// Type-check for unit strides
int stride = 1;
for (int i=rank-1; i>=0; --i) {
if (val.stride(i) != stride) {
fprintf(stderr, "Unexpected stride of %d (should be %d) in dimension %d (extent=%d) of %s (rank=%d)\n", val.stride(i), stride, i, val.extent(i), vname.c_str(), rank);
fprintf(stderr, "Are you trying to write a Fortran-style array? Use f_to_c() in blitz.hpp first\n");
throw std::exception();
}
//printf("(stride=%d) *= (val.extent[%d]=%d)\n", stride, i, val.extent(i));
stride *= val.extent(i);
}
// Create the required dimensions
NcDim const *dims[rank];
for (int i=0; i<rank; ++i) {
if (i >= ddims.size()) {
char dim_name[200];
sprintf(dim_name, "%s.dim%d", vname.c_str(), i);
dims[i] = nc.add_dim(dim_name, val.extent(i));
} else {
dims[i] = ddims[i];
}
assert(dims[i] != NULL);
}
// Create the variable
NcVar *nc_var = nc.add_var(vname.c_str(), get_nc_type<T>(), rank, dims);
assert(nc_var != NULL);
// Write it out (later)
return boost::bind(&netcdf_write_blitz<T,rank>, nc_var, val);
}
void CCohortdriver::createSoilClimate(BgcData *bd, EnvData *ed, Vegetation_Env *ve,
string& datadir){
string file = datadir+ "calirestart.nc";
NcFile* resFile = new NcFile(file.c_str(), NcFile::Replace);
NcDim * chtD = resFile->add_dim("CHTID", 1);
NcDim * monD = resFile->add_dim("MON", 12);
NcDim * layD = resFile->add_dim("LAYER", MAX_SOI_LAY);
NcVar* drgV = resFile->add_var("DRG",ncInt, chtD);
NcVar* vegV = resFile->add_var("VEG",ncInt, chtD);
NcVar* numslV = resFile->add_var("NUMSL",ncInt, chtD);
NcVar* rsoilcV = resFile->add_var("RSOILC", ncDouble, layD);
NcVar* nsoilcV = resFile->add_var("NSOILC", ncDouble, layD);
NcVar* dzV = resFile->add_var("DZ", ncDouble, layD);
NcVar* typeV = resFile->add_var("TYPE", ncDouble, layD);
NcVar* poroV = resFile->add_var("PORO", ncDouble, layD);
NcVar* rootfracV = resFile->add_var("ROOTFRAC", ncDouble, layD);
NcVar* taV = resFile->add_var("TA",ncDouble, monD);
NcVar* growV = resFile->add_var("GROW",ncDouble, monD);
NcVar* co2V = resFile->add_var("CO2",ncDouble, monD);
NcVar* petV = resFile->add_var("PET",ncDouble, monD);
NcVar* eetV = resFile->add_var("EET",ncDouble, monD);
NcVar* parV = resFile->add_var("PAR",ncDouble, monD);
NcVar* envlaiV = resFile->add_var("ENVLAI",ncFloat, monD);
NcVar* tsV = resFile->add_var("TS", ncDouble, monD, layD);
NcVar* ch4V = resFile->add_var("CH4",ncDouble, monD, layD);
NcVar* liqV = resFile->add_var("LIQ",ncDouble, monD, layD);
NcVar* vwcV = resFile->add_var("VSM",ncDouble, monD, layD);
NcVar* swsV = resFile->add_var("SWS",ncDouble, monD, layD);
NcVar* iceV = resFile->add_var("ICE",ncDouble, monD, layD);
NcVar* yreetV = resFile->add_var("YREET",ncDouble, chtD);
NcVar* yrpetV = resFile->add_var("YRPET",ncDouble, chtD);
NcVar* yrco2V = resFile->add_var("YRCO2",ncDouble, chtD);
NcVar* prveetmxV = resFile->add_var("PRVEETMX",ncDouble, chtD);
NcVar* prvpetmxV = resFile->add_var("PRVPETMX",ncDouble, chtD);
numslV->put(&ed->m_soid.actual_num_soil, 1);
drgV->put(&ed->cd->drgtype, 1);
vegV->put(&ed->cd->vegtype, 1);
poroV->put(&ed->m_sois.por[0], MAX_SOI_LAY);
typeV->put(&ed->m_sois.type[0], MAX_SOI_LAY);
dzV->put(&ed->m_sois.dz[0], MAX_SOI_LAY);
rsoilcV->put(&bd->m_sois.reac[0], MAX_SOI_LAY);
nsoilcV->put(&bd->m_sois.nonc[0], MAX_SOI_LAY);
rootfracV->put(&ed->m_sois.rootfrac[0], MAX_SOI_LAY);
tsV->put(&ed->eq_ts[0][0], 12, MAX_SOI_LAY);
ch4V->put(&ed->eq_ch4[0][0], 12, MAX_SOI_LAY);
liqV->put(&ed->eq_liq[0][0], 12, MAX_SOI_LAY);
iceV->put(&ed->eq_ice[0][0], 12, MAX_SOI_LAY);
vwcV->put(&ed->eq_vwc[0][0], 12, MAX_SOI_LAY);
swsV->put(&ed->eq_sws[0][0], 12, MAX_SOI_LAY);
taV->put(&ed->eq_ta[0], 12);
petV->put(&ed->eq_pet[0], 12);
eetV->put(&ed->eq_eet[0], 12);
co2V->put(&ed->eq_co2[0], 12);
parV->put(&ed->eq_par[0], 12);
growV->put(&ed->eq_grow[0], 12);
envlaiV->put(&ve->envlaiall[0], 12);
yreetV->put(&ed->eq_y_eet, 1);
yrpetV->put(&ed->eq_y_pet, 1);
yrco2V->put(&ed->eq_y_co2, 1);
prveetmxV->put(&ed->eq_prveetmx);
prvpetmxV->put(&ed->eq_prvpetmx);
resFile->close();
delete resFile; //Yuan: if not, memory leaking may occur
// exit(0);
};
void CopyNcVar(
NcFile & ncIn,
NcFile & ncOut,
const std::string & strVarName,
bool fCopyAttributes,
bool fCopyData
) {
if (!ncIn.is_valid()) {
_EXCEPTIONT("Invalid input file specified");
}
if (!ncOut.is_valid()) {
_EXCEPTIONT("Invalid output file specified");
}
NcVar * var = ncIn.get_var(strVarName.c_str());
if (var == NULL) {
_EXCEPTION1("NetCDF file does not contain variable \"%s\"",
strVarName.c_str());
}
NcVar * varOut;
std::vector<NcDim *> dimOut;
dimOut.resize(var->num_dims());
std::vector<long> counts;
counts.resize(var->num_dims());
long nDataSize = 1;
for (int d = 0; d < var->num_dims(); d++) {
NcDim * dimA = var->get_dim(d);
dimOut[d] = ncOut.get_dim(dimA->name());
if (dimOut[d] == NULL) {
if (dimA->is_unlimited()) {
dimOut[d] = ncOut.add_dim(dimA->name());
} else {
dimOut[d] = ncOut.add_dim(dimA->name(), dimA->size());
}
if (dimOut[d] == NULL) {
_EXCEPTION2("Failed to add dimension \"%s\" (%i) to file",
dimA->name(), dimA->size());
}
}
if (dimOut[d]->size() != dimA->size()) {
if (dimA->is_unlimited() && !dimOut[d]->is_unlimited()) {
_EXCEPTION2("Mismatch between input file dimension \"%s\" and "
"output file dimension (UNLIMITED / %i)",
dimA->name(), dimOut[d]->size());
} else if (!dimA->is_unlimited() && dimOut[d]->is_unlimited()) {
_EXCEPTION2("Mismatch between input file dimension \"%s\" and "
"output file dimension (%i / UNLIMITED)",
dimA->name(), dimA->size());
} else if (!dimA->is_unlimited() && !dimOut[d]->is_unlimited()) {
_EXCEPTION3("Mismatch between input file dimension \"%s\" and "
"output file dimension (%i / %i)",
dimA->name(), dimA->size(), dimOut[d]->size());
}
}
counts[d] = dimA->size();
nDataSize *= counts[d];
}
// ncByte / ncChar type
if ((var->type() == ncByte) || (var->type() == ncChar)) {
DataVector<char> data;
data.Initialize(nDataSize);
varOut =
ncOut.add_var(
var->name(), var->type(),
dimOut.size(), (const NcDim**)&(dimOut[0]));
if (varOut == NULL) {
_EXCEPTION1("Cannot create variable \"%s\"", var->name());
}
var->get(&(data[0]), &(counts[0]));
varOut->put(&(data[0]), &(counts[0]));
}
// ncShort type
if (var->type() == ncShort) {
DataVector<short> data;
data.Initialize(nDataSize);
varOut =
ncOut.add_var(
var->name(), var->type(),
dimOut.size(), (const NcDim**)&(dimOut[0]));
if (varOut == NULL) {
_EXCEPTION1("Cannot create variable \"%s\"", var->name());
}
if (fCopyData) {
var->get(&(data[0]), &(counts[0]));
varOut->put(&(data[0]), &(counts[0]));
}
}
// ncInt type
if (var->type() == ncInt) {
DataVector<int> data;
data.Initialize(nDataSize);
varOut =
ncOut.add_var(
var->name(), var->type(),
dimOut.size(), (const NcDim**)&(dimOut[0]));
if (varOut == NULL) {
_EXCEPTION1("Cannot create variable \"%s\"", var->name());
}
if (fCopyData) {
var->get(&(data[0]), &(counts[0]));
varOut->put(&(data[0]), &(counts[0]));
}
}
// ncFloat type
if (var->type() == ncFloat) {
DataVector<float> data;
data.Initialize(nDataSize);
varOut =
ncOut.add_var(
var->name(), var->type(),
dimOut.size(), (const NcDim**)&(dimOut[0]));
if (varOut == NULL) {
_EXCEPTION1("Cannot create variable \"%s\"", var->name());
}
if (fCopyData) {
var->get(&(data[0]), &(counts[0]));
varOut->put(&(data[0]), &(counts[0]));
}
}
// ncDouble type
if (var->type() == ncDouble) {
DataVector<double> data;
data.Initialize(nDataSize);
varOut =
ncOut.add_var(
var->name(), var->type(),
dimOut.size(), (const NcDim**)&(dimOut[0]));
if (varOut == NULL) {
_EXCEPTION1("Cannot create variable \"%s\"", var->name());
}
if (fCopyData) {
var->get(&(data[0]), &(counts[0]));
varOut->put(&(data[0]), &(counts[0]));
}
}
// ncInt64 type
if (var->type() == ncInt64) {
DataVector<ncint64> data;
data.Initialize(nDataSize);
varOut =
ncOut.add_var(
var->name(), var->type(),
dimOut.size(), (const NcDim**)&(dimOut[0]));
if (varOut == NULL) {
_EXCEPTION1("Cannot create variable \"%s\"", var->name());
}
if (fCopyData) {
var->get(&(data[0]), &(counts[0]));
varOut->put(&(data[0]), &(counts[0]));
}
}
// Check output variable exists
if (varOut == NULL) {
_EXCEPTION1("Unable to create output variable \"%s\"",
var->name());
}
// Copy attributes
if (fCopyAttributes) {
CopyNcVarAttributes(var, varOut);
}
}
//
// Creates NetCDF product
//
bool NetCDFProduct(MSG_header *PRO_head, MSG_data* PRO_data,
int totalsegs, int *segsindexes,
MSG_header *header, MSG_data *msgdat)
{
struct tm *tmtime;
char NcName[1024];
char reftime[64];
char projname[16];
int wd, hg;
int bpp;
int ncal;
float *cal;
NcVar *ivar;
NcVar *tvar;
NcDim *tdim;
NcDim *ldim;
NcDim *cdim;
NcDim *caldim;
int npix = header[0].image_structure->number_of_columns;
int nlin = header[0].image_structure->number_of_lines;
size_t npixperseg = npix*nlin;
size_t total_size = totalsegs*npixperseg;
MSG_SAMPLE *pixels = new MSG_SAMPLE[total_size];
memset(pixels, 0, total_size*sizeof(MSG_SAMPLE));
size_t pos = 0;
for (int i = 0; i < totalsegs; i ++)
{
if (segsindexes[i] >= 0)
memcpy(pixels+pos, msgdat[segsindexes[i]].image->data,
npixperseg*sizeof(MSG_SAMPLE));
pos += npixperseg;
}
nlin = nlin*totalsegs;
// Manage subarea
if (is_subarea)
{
if (AreaLinStart < 0 ||
AreaLinStart > nlin - AreaNlin ||
AreaNlin > nlin - AreaLinStart)
{
std::cerr << "Wrong Subarea in lines...." << std::endl;
throw;
}
if (AreaPixStart < 0 ||
AreaPixStart > npix - AreaNpix ||
AreaNpix > npix - AreaPixStart)
{
std::cerr << "Wrong Subarea in Pixels...." << std::endl;
throw;
}
size_t newsize = AreaNpix * AreaNlin;
MSG_SAMPLE *newpix = new MSG_SAMPLE[newsize];
memset(newpix, 0, newsize*sizeof(MSG_SAMPLE));
for (int i = 0; i < AreaNlin; i ++)
memcpy(newpix + i * AreaNpix,
pixels + (AreaLinStart + i) * npix + AreaPixStart,
AreaNpix * sizeof(MSG_SAMPLE));
delete [ ] pixels;
pixels = newpix;
total_size = newsize;
}
else
{
AreaNpix = npix;
AreaNlin = nlin;
}
tmtime = PRO_data->prologue->image_acquisition.PlannedAquisitionTime.TrueRepeatCycleStart.get_timestruct( );
t_enum_MSG_spacecraft spc = header[0].segment_id->spacecraft_id;
uint_1 chn = header[0].segment_id->spectral_channel_id;
float sublon = header[0].image_navigation->subsatellite_longitude;
int cfac = header[0].image_navigation->column_scaling_factor;
int lfac = header[0].image_navigation->line_scaling_factor;
int coff = header[0].image_navigation->column_offset;
int loff = header[0].image_navigation->line_offset;
float sh = header[0].image_navigation->satellite_h;
char *channelstring = strdup(MSG_channel_name(spc, chn).c_str( ));
char *channel = chname(channelstring, strlen(channelstring) + 1);
// Build up output NetCDF file name and open it
sprintf( NcName, "%s_%4d%02d%02d_%02d%02d.nc", channel,
tmtime->tm_year + 1900, tmtime->tm_mon + 1, tmtime->tm_mday,
tmtime->tm_hour, tmtime->tm_min );
NcFile ncf ( NcName , NcFile::Replace );
if (! ncf.is_valid()) return false;
// Fill arrays on creation
ncf.set_fill(NcFile::Fill);
// Add Global Attributes
if (! ncf.add_att("Satellite", MSG_spacecraft_name(spc).c_str()))
return false;
sprintf(reftime, "%04d-%02d-%02d %02d:%02d:00 UTC",
tmtime->tm_year + 1900, tmtime->tm_mon + 1, tmtime->tm_mday,
tmtime->tm_hour, tmtime->tm_min);
if (! ncf.add_att("Antenna", "Fixed") ) return false;
if (! ncf.add_att("Receiver", "HIMET") ) return false;
if (! ncf.add_att("Time", reftime) ) return false;
if (! ncf.add_att("Area_Name", "SpaceView" ) ) return false;
sprintf(projname, "GEOS(%3.1f)", sublon);
if (! ncf.add_att("Projection", projname) ) return false;
if (! ncf.add_att("Columns", AreaNpix ) ) return false;
if (! ncf.add_att("Lines", AreaNlin ) ) return false;
if (! ncf.add_att("SampleX", 1.0 ) ) return false;
if (! ncf.add_att("SampleY", 1.0 ) ) return false;
if (! ncf.add_att("AreaStartPix", AreaPixStart ) ) return false;
if (! ncf.add_att("AreaStartLin", AreaLinStart ) ) return false;
if (! ncf.add_att("Column_Scale_Factor", cfac) ) return false;
if (! ncf.add_att("Line_Scale_Factor", lfac) ) return false;
if (! ncf.add_att("Column_Offset", coff) ) return false;
if (! ncf.add_att("Line_Offset", loff) ) return false;
if (! ncf.add_att("Orbit_Radius", sh) ) return false;
if (! ncf.add_att("Longitude", sublon) ) return false;
if (! ncf.add_att("NortPolar", 1) ) return false;
if (! ncf.add_att("NorthSouth", 1) ) return false;
if (! ncf.add_att("title", TITLE) ) return false;
if (! ncf.add_att("Institution", INSTITUTION) ) return false;
if (! ncf.add_att("Type", TYPE) ) return false;
if (! ncf.add_att("Version", HIMET_VERSION) ) return false;
if (! ncf.add_att("Conventions", "COARDS") ) return false;
if (! ncf.add_att("history", "Created from raw data") ) return false;
// Dimensions
wd = AreaNpix;
hg = AreaNlin;
bpp = header[0].image_structure->number_of_bits_per_pixel;
ncal = (int) pow(2.0, bpp);
tdim = ncf.add_dim("time");
if (!tdim->is_valid()) return false;
ldim = ncf.add_dim("line", hg);
if (!ldim->is_valid()) return false;
cdim = ncf.add_dim("column", wd);
if (!cdim->is_valid()) return false;
caldim = ncf.add_dim("calibration", ncal);
if (!caldim->is_valid()) return false;
// Get calibration values
cal = PRO_data->prologue->radiometric_proc.get_calibration((int) chn, bpp);
// Add Calibration values
NcVar *cvar = ncf.add_var("calibration", ncFloat, caldim);
if (!cvar->is_valid()) return false;
cvar->add_att("long_name", "Calibration coefficients");
cvar->add_att("variable", channel);
if (chn > 3 && chn < 12)
cvar->add_att("units", "K");
else
cvar->add_att("units", "mW m^-2 sr^-1 (cm^-1)^-1");
if (!cvar->put(cal, ncal)) return false;
tvar = ncf.add_var("time", ncDouble, tdim);
if (!tvar->is_valid()) return false;
tvar->add_att("long_name", "Time");
tvar->add_att("units", "seconds since 2000-01-01 00:00:00 UTC");
double atime;
time_t ttime;
extern long timezone;
ttime = mktime(tmtime);
atime = ttime - 946684800 - timezone;
if (!tvar->put(&atime, 1)) return false;
ivar = ncf.add_var(channel, ncShort, tdim, ldim, cdim);
if (!ivar->is_valid()) return false;
if (!ivar->add_att("add_offset", 0.0)) return false;
if (!ivar->add_att("scale_factor", 1.0)) return false;
if (!ivar->add_att("chnum", chn)) return false;
// Write output values
if (!ivar->put((const short int *) pixels, 1, hg, wd)) return false;
// Close NetCDF output
(void) ncf.close( );
delete [ ] pixels;
delete [ ] cal;
return( true );
}
void ice_write ( std::string filename, int dim, int vertices, int edges,
int triangles, int quadrilaterals, int tetrahedrons, int hexahedrons,
double vertex_coordinate[], int vertex_label[], int edge_vertex[],
int edge_label[], int triangle_vertex[], int triangle_label[],
int quadrilateral_vertex[], int quadrilateral_label[],
int tetrahedron_vertex[], int tetrahedron_label[],
int hexahedron_vertex[], int hexahedron_label[] )
//****************************************************************************80
//
// Purpose:
//
// ICE_WRITE writes 3D ICE sizes and data to a NETCDF file.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 30 November 2010
//
// Author:
//
// John Burkardt
//
// Reference:
//
// Pascal Frey,
// MEDIT: An interactive mesh visualization software,
// Technical Report RT-0253,
// Institut National de Recherche en Informatique et en Automatique,
// 03 December 2001.
//
// Parameters:
//
// Input, string FILENAME, the name of the file to be created.
// Ordinarily, the name should include the extension ".nc".
//
// Input, int DIM, the spatial dimension, which should be 3.
//
// Input, int VERTICES, the number of vertices.
//
// Input, int EDGES, the number of edges (may be 0).
//
// Input, int TRIANGLES, the number of triangles (may be 0).
//
// Input, int QUADRILATERALS, the number of quadrilaterals (may be 0).
//
// Input, int TETRAHEDRONS, the number of tetrahedrons (may be 0).
//
// Input, int HEXAHEDRONS, the number of hexahedrons (may be 0).
//
// Input, double VERTEX_COORDINATE[3*VERTICES], the XYZ coordinates
// of each vertex.
//
// Input, int VERTEX_LABEL[VERTICES], a label for each vertex.
//
// Input, int EDGE_VERTEX[2*EDGES], the vertices that form each edge.
//
// Input, int EDGE_LABEL[EDGES], a label for each edge.
//
// Input, int TRIANGLE_VERTEX[3*TRIANGLES], the vertices that form
// each triangle.
//
// Input, int TRIANGLE_LABEL[TRIANGLES], a label for each triangle.
//
// Input, int QUADRILATERAL_VERTEX[4*QUADRILATERALS], the vertices that
// form each quadrilateral.
//
// Input, int QUADRILATERAL_LABEL[QUADRILATERALS], a label for
// each quadrilateral.
//
// Input, int TETRAHEDRON_VERTEX[4*TETRAHEDRONS], the vertices that
// form each tetrahedron.
//
// Input, int TETRAHEDRON_LABEL[TETRAHEDRONS], a label for
// each tetrahedron.
//
// Input, int HEXAHEDRON_VERTEX[8*HEXAHEDRONS], the vertices that form
// each hexahedron.
//
// Input, int HEXAHEDRON_LABEL[HEXAHEDRONS], a label for each hexahedron.
//
{
NcDim *dim_dimension;
NcDim *dim_edges;
NcDim *dim_eight;
NcDim *dim_four;
NcDim *dim_hexahedrons;
NcDim *dim_quadrilaterals;
NcDim *dim_tetrahedrons;
NcDim *dim_three;
NcDim *dim_triangles;
NcDim *dim_two;
NcDim *dim_vertices;
NcVar *var_edge_vertex;
NcVar *var_edge_label;
NcVar *var_hexahedron_vertex;
NcVar *var_hexahedron_label;
NcVar *var_quadrilateral_vertex;
NcVar *var_quadrilateral_label;
NcVar *var_tetrahedron_vertex;
NcVar *var_tetrahedron_label;
NcVar *var_triangle_vertex;
NcVar *var_triangle_label;
NcVar *var_vertex_coordinate;
NcVar *var_vertex_label;
//
// Create the file.
//
NcFile dataFile ( filename.c_str ( ), NcFile::Replace );
if ( !dataFile.is_valid ( ) )
{
cout << "\n";
cout << "ICE_WRITE - Fatal error!\n";
cout << " Could not open the file.\n";
exit ( 1 );
}
//
// Dimension information.
//
dim_dimension = dataFile.add_dim ( "Dimension", dim );
dim_vertices = dataFile.add_dim ( "Vertices", vertices );
if ( 0 < edges )
{
dim_edges = dataFile.add_dim ( "Edges", edges );
}
if ( 0 < triangles )
{
dim_triangles = dataFile.add_dim ( "Triangles", triangles );
}
if ( 0 < quadrilaterals )
{
dim_quadrilaterals = dataFile.add_dim ( "Quadrilaterals", quadrilaterals );
}
if ( 0 < tetrahedrons )
{
dim_tetrahedrons = dataFile.add_dim ( "Tetrahedrons", tetrahedrons );
}
if ( 0 < hexahedrons )
{
dim_hexahedrons = dataFile.add_dim ( "Hexahedrons", hexahedrons );
}
dim_two = dataFile.add_dim ( "Two", 2 );
dim_three = dataFile.add_dim ( "Three", 3 );
dim_four = dataFile.add_dim ( "Four", 4 );
dim_eight = dataFile.add_dim ( "Eight", 8 );
//
// Define variables.
//
var_vertex_coordinate = dataFile.add_var ( "Vertex_Coordinate", ncDouble, dim_three, dim_vertices );
var_vertex_label = dataFile.add_var ( "Vertex_Label", ncInt, dim_vertices );
if ( 0 < edges )
{
var_edge_vertex = dataFile.add_var ( "Edge_Vertex", ncInt, dim_two, dim_edges );
var_edge_label = dataFile.add_var ( "Edge_Label", ncInt, dim_edges );
}
if ( 0 < triangles )
{
var_triangle_vertex = dataFile.add_var ( "Triangle_Vertex", ncInt, dim_three, dim_triangles );
var_triangle_label = dataFile.add_var ( "Triangle_Label", ncInt, dim_triangles );
}
if ( 0 < quadrilaterals )
{
var_quadrilateral_vertex = dataFile.add_var ( "Quadrilateral_Vertex", ncInt, dim_four, dim_quadrilaterals );
var_quadrilateral_label = dataFile.add_var ( "Quadrilateral_Label", ncInt, dim_quadrilaterals );
}
if ( 0 < tetrahedrons )
{
var_tetrahedron_vertex = dataFile.add_var ( "Tetrahedron_Vertex", ncInt, dim_four, dim_tetrahedrons );
var_tetrahedron_label = dataFile.add_var ( "Tetrahedron_Label", ncInt, dim_tetrahedrons );
}
if ( 0 < hexahedrons )
{
var_hexahedron_vertex = dataFile.add_var ( "Hexahedron_Vertex", ncInt, dim_eight, dim_hexahedrons );
var_hexahedron_label = dataFile.add_var ( "Hexahedron_Label", ncInt, dim_hexahedrons );
}
//
// Write the data.
//
var_vertex_coordinate->put ( &vertex_coordinate[0], 3, vertices );
var_vertex_label->put ( &vertex_label[0], vertices );
if ( 0 < edges )
{
var_edge_vertex->put ( &edge_vertex[0], 2, edges );
var_edge_label->put ( &edge_label[0], edges );
}
if ( 0 < triangles )
{
var_triangle_vertex->put ( &triangle_vertex[0], 3, triangles );
var_triangle_label->put ( &triangle_label[0], triangles );
}
if ( 0 < quadrilaterals )
{
var_quadrilateral_vertex->put ( &quadrilateral_vertex[0], 4, quadrilaterals );
var_quadrilateral_label->put ( &quadrilateral_label[0], quadrilaterals );
}
if ( 0 < tetrahedrons )
{
var_tetrahedron_vertex->put ( &tetrahedron_vertex[0], 4, tetrahedrons );
var_tetrahedron_label->put ( &tetrahedron_label[0], tetrahedrons );
}
if ( 0 < hexahedrons )
{
var_hexahedron_vertex->put ( &hexahedron_vertex[0], 8, hexahedrons );
var_hexahedron_label->put ( &hexahedron_label[0], hexahedrons );
}
//
// Close the file.
//
dataFile.close ( );
return;
}