bool ReadAstro::open(const char *path)
{
assert(!m_ncfile);
m_ncfile = new NcFile(path, NcFile::ReadOnly);
if (!m_ncfile->is_valid())
{
close();
sendError("failed to open NetCDF file %s", path);
return false;
}
if (m_ncfile->get_format() == NcFile::BadFormat)
{
close();
sendError("bad NetCDF file");
return false;
}
fprintf(stderr, "dims=%d, vars=%d, attrs=%d\n",
m_ncfile->num_dims(), m_ncfile->num_vars(), m_ncfile->num_atts());
for (int i = 0; i < m_ncfile->num_dims(); ++i)
{
fprintf(stderr, "%s: %ld\n",
m_ncfile->get_dim(i)->name(),
m_ncfile->get_dim(i)->size());
}
for (int i = 0; i < m_ncfile->num_vars(); ++i)
{
fprintf(stderr, "%s: dims=%d atts=%d vals=%ld type=%d\n",
m_ncfile->get_var(i)->name(),
m_ncfile->get_var(i)->num_dims(),
m_ncfile->get_var(i)->num_atts(),
m_ncfile->get_var(i)->num_vals(),
m_ncfile->get_var(i)->type());
//int dims = m_ncfile->get_var(i)->num_dims();
NcVar *var = m_ncfile->get_var(i);
for (int j = 0; j < var->num_dims(); ++j)
{
fprintf(stderr, " %s: %ld edge=%ld\n",
var->get_dim(j)->name(),
var->get_dim(j)->size(),
var->edges()[j]);
}
}
for (int i = 0; i < m_ncfile->num_atts(); ++i)
{
fprintf(stderr, "%s\n", m_ncfile->get_att(i)->name());
}
return true;
}
bool FileArome::isValid(std::string iFilename) {
bool status = false;
NcFile file = NcFile(iFilename.c_str(), NcFile::ReadOnly);
if(file.is_valid()) {
status = hasDim(file, "time") && hasDim(file, "x") && hasDim(file, "y") &&
!hasDim(file, "ensemble_member") &&
hasVar(file, "latitude") && hasVar(file, "longitude");
}
file.close();
return status;
}
void FlowManager::output(const string &fileName) const
{
NcFile *file;
struct stat statInfo;
int ret = stat(fileName.c_str(), &statInfo);
NcError ncError(NcError::silent_nonfatal);
if (ret != 0 || TimeManager::isFirstStep()) {
file = new NcFile(fileName.c_str(), NcFile::Replace);
} else {
file = new NcFile(fileName.c_str(), NcFile::Write);
}
if (!file->is_valid()) {
char message[100];
sprintf(message, "Failed to open file %s.", fileName.c_str());
REPORT_ERROR(message)
}
const bool read( const std::string filename )
{
if ( m_file ) delete m_file;
m_filename = filename;
m_file = new NcFile( filename.c_str(), NcFile::ReadOnly );
if ( !m_file ) return( false );
if ( !m_file->is_valid() ) return( false );
const int ndims = m_file->num_dims();
for ( int i = 0; i < ndims; i++ )
{
m_dims.push_back( new Dim( m_file->get_dim(i) ) );
}
const int nvars = m_file->num_vars();
for ( int i = 0; i < nvars; i++ )
{
m_vars.push_back( new Var( m_file->get_var(i) ) );
}
return( true );
}
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);
}
}
//
// Reads variable data from dump file
//
bool DataVar::initFromFile(const string& filename, const_DomainChunk_ptr dom)
{
cleanup();
#if ESYS_HAVE_NETCDF
NcError ncerr(NcError::silent_nonfatal);
NcFile* input = new NcFile(filename.c_str());
if (!input->is_valid()) {
cerr << "Could not open input file " << filename << "." << endl;
delete input;
return false;
}
NcDim* dim;
NcAtt* att;
att = input->get_att("type_id");
int typeID = att->as_int(0);
if (typeID != 2) {
cerr << "WARNING: Only expanded data supported!" << endl;
delete input;
return false;
}
att = input->get_att("rank");
rank = att->as_int(0);
dim = input->get_dim("num_data_points_per_sample");
ptsPerSample = dim->size();
att = input->get_att("function_space_type");
funcSpace = att->as_int(0);
centering = dom->getCenteringForFunctionSpace(funcSpace);
dim = input->get_dim("num_samples");
numSamples = dim->size();
#ifdef _DEBUG
cout << varName << ":\t" << numSamples << " samples, "
<< ptsPerSample << " pts/s, rank: " << rank << endl;
#endif
domain = dom;
NodeData_ptr nodes = domain->getMeshForFunctionSpace(funcSpace);
if (nodes == NULL) {
delete input;
return false;
}
meshName = nodes->getName();
siloMeshName = nodes->getFullSiloName();
initialized = true;
size_t dimSize = 1;
vector<long> counts;
if (rank > 0) {
dim = input->get_dim("d0");
int d = dim->size();
shape.push_back(d);
counts.push_back(d);
dimSize *= d;
}
if (rank > 1) {
dim = input->get_dim("d1");
int d = dim->size();
shape.push_back(d);
counts.push_back(d);
dimSize *= d;
}
if (rank > 2) {
cerr << "WARNING: Rank " << rank << " data is not supported!\n";
initialized = false;
}
if (initialized && numSamples > 0) {
sampleID.insert(sampleID.end(), numSamples, 0);
NcVar* var = input->get_var("id");
var->get(&sampleID[0], numSamples);
size_t dataSize = dimSize*numSamples*ptsPerSample;
counts.push_back(ptsPerSample);
counts.push_back(numSamples);
float* tempData = new float[dataSize];
var = input->get_var("data");
var->get(tempData, &counts[0]);
const float* srcPtr = tempData;
for (size_t i=0; i < dimSize; i++, srcPtr++) {
float* c = averageData(srcPtr, dimSize);
dataArray.push_back(c);
}
delete[] tempData;
initialized = reorderSamples();
}
delete input;
#endif // ESYS_HAVE_NETCDF
return initialized;
}
//
// 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 size_read ( string filename, int *dim, int *vertices, int *edges,
int *triangles, int *quadrilaterals, int *tetrahedrons, int *hexahedrons )
//*****************************************************************************80
//
// Purpose:
//
// SIZE_READ reads ICE sizes from 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 read.
// Ordinarily, the name should include the extension ".nc".
//
// Output, int *DIM, the spatial dimension, which should be 2 or 3.
//
// Output, int *VERTICES, the number of vertices.
//
// Output, int *EDGES, the number of edges (may be 0).
//
// Output, int *TRIANGLES, the number of triangles (may be 0).
//
// Output, int *QUADRILATERALS, the number of quadrilaterals (may be 0).
//
// Output, int *TETRAHEDRONS, the number of tetrahedrons (may be 0).
//
// Output, int *HEXAHEDRONS, the number of hexahedrons (may be 0).
//
{
NcDim *dim_dimension;
NcDim *dim_edges;
NcDim *dim_eight;
NcDim *dim_four;
NcDim *dim_hexahedrons;
NcToken dim_name;
int dim_num;
NcDim *dim_quadrilaterals;
NcDim *dim_tetrahedrons;
NcDim *dim_three;
NcDim *dim_triangles;
NcDim *dim_two;
NcDim *dim_vertices;
NcDim *dim_pointer;
int i;
//
// Initialize everything to nothing.
//
*dim = 0;
*vertices = 0;
*edges = 0;
*triangles = 0;
*quadrilaterals = 0;
*tetrahedrons = 0;
*hexahedrons = 0;
//
// Open the file in "read only" mode.
//
NcFile dataFile ( filename.c_str ( ), NcFile::ReadOnly );
if ( !dataFile.is_valid ( ) )
{
cout << "\n";
cout << "SIZE_READ: Fatal error!\n";
cout << " Could not open file.\n";
exit ( 1 );
}
//
// Get the dimension information.
//
// I would much prefer to write "0" as the size of certain dimensions, but I am not
// allowed to, so I simply omit them from the file.
//
// Therefore, when I open the file and try to determine dimensions, some dimensions
// are "missing", which I would have presumed I could discover painlessly by asking
// for pointers to them, and getting NULLs back. But that doesn't seem to work either.
//
// So my bonehead backup is simply to read all the dimensions by index, retrieve
// their names, and see what I find.
//
dim_num = dataFile.num_dims ( );
for ( i = 0; i < dim_num; i++ )
{
dim_pointer = dataFile.get_dim ( i );
dim_name = dim_pointer->name ( );
if ( !strcmp ( dim_name, "Dimension" ) )
{
*dim = dim_pointer->size ( );
}
else if ( !strcmp ( dim_name, "Vertices" ) )
{
*vertices = dim_pointer->size ( );
}
else if ( !strcmp ( dim_name, "Edges" ) )
{
*edges = dim_pointer->size ( );
}
else if ( !strcmp ( dim_name, "Triangles" ) )
{
*triangles = dim_pointer->size ( );
}
else if ( !strcmp ( dim_name, "Quadrilaterals" ) )
{
*quadrilaterals = dim_pointer->size ( );
}
else if ( !strcmp ( dim_name, "Tetrahedrons" ) )
{
*tetrahedrons = dim_pointer->size ( );
}
else if ( !strcmp ( dim_name, "Hexahedrons" ) )
{
*hexahedrons = dim_pointer->size ( );
}
else
{
cout << " Ignoring information about dimension \"" << dim_name << "\".\n";
}
}
//
// Close the file.
//
dataFile.close ( );
return;
}
void data_read ( 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:
//
// DATA_READ reads ICE data from 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.
//
// Russ Rew,
// The NetCDF C++ Interface Guide,
// Unidata Program Center, August 2008.
//
// Parameters:
//
// Input, string FILENAME, the name of the file to be read.
// Ordinarily, the name should include the extension ".nc".
//
// Input, int DIM, the spatial dimension, which should be 2 or 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).
//
// Output, double VERTEX_COORDINATE[DIM*VERTICES], the coordinates
// of each vertex.
//
// Output, int VERTEX_LABEL[VERTICES], a label for each vertex.
//
// Output, int EDGE_VERTEX[2*EDGES], the vertices that form each edge.
//
// Output, int EDGE_LABEL[EDGES], a label for each edge.
//
// Output, int TRIANGLE_VERTEX[3*TRIANGLES], the vertices that form
// each triangle.
//
// Output, int TRIANGLE_LABEL[TRIANGLES], a label for each triangle.
//
// Output, int QUADRILATERAL_VERTEX[4*QUADRILATERALS], the vertices that
// form each quadrilateral.
//
// Output, int QUADRILATERAL_LABEL[QUADRILATERALS], a label for
// each quadrilateral.
//
// Output, int TETRAHEDRON_VERTEX[4*TETRAHEDRONS], the vertices that
// form each tetrahedron.
//
// Output, int TETRAHEDRON_LABEL[TETRAHEDRONS], a label for
// each tetrahedron.
//
// Output, int HEXAHEDRON_VERTEX[8*HEXAHEDRONS], the vertices that form
// each hexahedron.
//
// Output, int HEXAHEDRON_LABEL[HEXAHEDRONS], a label for each hexahedron.
//
{
//
// Open the file in "read only" mode.
//
NcFile dataFile ( filename.c_str ( ), NcFile::ReadOnly );
if ( !dataFile.is_valid ( ) )
{
cout << "\n";
cout << "DATA_READ: Fatal error!\n";
cout << " Could not open file.\n";
exit ( 1 );
}
//
// Vertices.
//
NcVar *var_vertex_coordinate = dataFile.get_var ( "Vertex_Coordinate" );
var_vertex_coordinate->get ( &vertex_coordinate[0], dim, vertices );
NcVar *var_vertex_label = dataFile.get_var ( "Vertex_Label" );
var_vertex_label->get ( &vertex_label[0], vertices );
//
// Edges.
//
if ( 0 < edges )
{
NcVar *var_edge_vertex = dataFile.get_var ( "Edge_Vertex" );
var_edge_vertex->get ( &edge_vertex[0], 2, edges );
NcVar *var_edge_label = dataFile.get_var ( "Edge_Label" );
var_edge_label->get ( &edge_label[0], edges );
}
//
// Triangles.
//
if ( 0 < triangles )
{
NcVar *var_triangle_vertex = dataFile.get_var ( "Triangle_Vertex" );
var_triangle_vertex->get ( &triangle_vertex[0], 3, triangles );
NcVar *var_triangle_label = dataFile.get_var ( "Triangle_Label" );
var_triangle_label->get ( &triangle_label[0], triangles );
}
//
// Quadrilaterals.
//
if ( 0 < quadrilaterals )
{
NcVar *var_quadrilateral_vertex = dataFile.get_var ( "Quadrilateral_Vertex" );
var_quadrilateral_vertex->get ( &quadrilateral_vertex[0], 4, quadrilaterals );
NcVar *var_quadrilateral_label = dataFile.get_var ( "Quadrilateral_Label" );
var_quadrilateral_label->get ( &quadrilateral_label[0], quadrilaterals );
}
//
// Tetrahedrons.
//
if ( 0 < tetrahedrons )
{
NcVar *var_tetrahedron_vertex = dataFile.get_var ( "Tetrahedron_Vertex" );
var_tetrahedron_vertex->get ( &tetrahedron_vertex[0], 4, tetrahedrons );
NcVar *var_tetrahedron_label = dataFile.get_var ( "Tetrahedron_Label" );
var_tetrahedron_label->get ( &tetrahedron_label[0], tetrahedrons );
}
//
// Hexahedrons.
//
if ( 0 < hexahedrons )
{
NcVar *var_hexahedron_vertex = dataFile.get_var ( "Hexahedron_Vertex" );
var_hexahedron_vertex->get ( &hexahedron_vertex[0], 8, hexahedrons );
NcVar *var_hexahedron_label = dataFile.get_var ( "Hexahedron_Label" );
var_hexahedron_label->get ( &hexahedron_label[0], hexahedrons );
}
//
// Close the file.
//
dataFile.close ( );
return;
}
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;
}
