eavlField* eavlNetCDFImporter::GetField(const string &name, const string &mesh, int) { for (unsigned int v=0; v<vars.size(); v++) { NcVar *var = vars[v]; if (name != var->name()) continue; if (debugoutput) cerr << "reading var "<<v+1<<" / "<<vars.size()<<endl; eavlFloatArray *arr = new eavlFloatArray(var->name(), 1); arr->SetNumberOfTuples(var->num_vals()); NcValues *vals = var->values(); int n = var->num_vals(); for (int i=0; i<n; i++) { arr->SetComponentFromDouble(i,0, vals->as_double(i)); } eavlField *field = new eavlField(1, arr, eavlField::ASSOC_POINTS); return field; } return NULL; }
bool NetcdfSource::initFile() { _ncfile = new NcFile(_filename.toUtf8().data(), NcFile::ReadOnly); if (!_ncfile->is_valid()) { qDebug() << _filename << ": failed to open in initFile()" << endl; return false; } KST_DBG qDebug() << _filename << ": building field list" << endl; _fieldList.clear(); _fieldList += "INDEX"; int nb_vars = _ncfile->num_vars(); KST_DBG qDebug() << nb_vars << " vars found in total" << endl; _maxFrameCount = 0; for (int i = 0; i < nb_vars; i++) { NcVar *var = _ncfile->get_var(i); if (var->num_dims() == 0) { _scalarList += var->name(); } else if (var->num_dims() == 1) { _fieldList += var->name(); int fc = var->num_vals() / var->rec_size(); _maxFrameCount = qMax(_maxFrameCount, fc); _frameCounts[var->name()] = fc; } else if (var->num_dims() == 2) { _matrixList += var->name(); } } // Get strings int globalAttributesNb = _ncfile->num_atts(); for (int i = 0; i < globalAttributesNb; ++i) { // Get only first value, should be enough for a start especially as strings are complete NcAtt *att = _ncfile->get_att(i); if (att) { QString attrName = QString(att->name()); char *attString = att->as_string(0); QString attrValue = QString(att->as_string(0)); delete[] attString; //TODO port //KstString *ms = new KstString(KstObjectTag(attrName, tag()), this, attrValue); _stringList += attrName; } delete att; } // TODO update(); // necessary? slows down initial loading return true; }
void DumpableNcFile::dumpvars( void ) { int n; static const char* types[] = {"","byte","char","short","long","float","double"}; NcVar* vp; for(n = 0; vp = get_var(n); n++) { cout << "\t" << types[vp->type()] << " " << vp->name() ; if (vp->num_dims() > 0) { cout << "("; for (int d = 0; d < vp->num_dims(); d++) { NcDim* dim = vp->get_dim(d); cout << dim->name(); if (d < vp->num_dims()-1) cout << ", "; } cout << ")"; } cout << " ;\n"; // now dump each of this variable's attributes dumpatts(*vp); } }
void NetCdfConfigureDialog::setVariableSelect() { for (int i=0; i<(_currentFile->num_vars()); i++) { NcVar *focusedVar = _currentFile->get_var(i); if (focusedVar->num_dims() > 0) comboBoxVariable->addItem(focusedVar->name()); } }
void DumpableNcFile::dumpdata( ) { NcVar* vp; for (int n = 0; vp = get_var(n); n++) { cout << " " << vp->name() << " = "; NcValues* vals = vp->values(); cout << *vals << " ;" << endl ; delete vals; } }
vector<string> eavlNetCDFImporter::GetFieldList(const string &mesh) { vector<string> retval; for (unsigned int v=0; v<vars.size(); v++) { NcVar *var = vars[v]; retval.push_back(var->name()); } return retval; }
void dumpatts(NcVar& var) { NcToken vname = var.name(); NcAtt* ap; for(int n = 0; ap = var.get_att(n); n++) { cout << "\t\t" << vname << ":" << ap->name() << " = " ; NcValues* vals = ap->values(); cout << *vals << " ;" << endl ; delete ap; delete vals; } }
Kst::Object::UpdateType NetcdfSource::internalDataSourceUpdate() { //TODO port /* if (KstObject::checkUpdateCounter(u)) { return lastUpdateResult(); } */ _ncfile->sync(); bool updated = false; /* Update member variables _ncfile, _maxFrameCount, and _frameCounts and indicate that an update is needed */ int nb_vars = _ncfile->num_vars(); for (int j = 0; j < nb_vars; j++) { NcVar *var = _ncfile->get_var(j); int fc = var->num_vals() / var->rec_size(); _maxFrameCount = qMax(_maxFrameCount, fc); updated = updated || (_frameCounts[var->name()] != fc); _frameCounts[var->name()] = fc; } return updated ? Object::Updated : Object::NoChange; }
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); } }
int main(int argc, char** argv) { if (!cmdline(argc, argv)) { printhelp(); return EXIT_FAILURE; } NcFile infile(infilename.c_str(), NcFile::ReadOnly); if (!infile.is_valid()) { std::cerr << "Error: invalid input file -- '" << infilename << "'" << std::endl; infile.close(); return EXIT_FAILURE; } NcFile outfile(outfilename.c_str(), NcFile::Replace); if (!outfile.is_valid()) { std::cerr << "Error: cannot open output file -- '" << outfilename << "'" << std::endl; outfile.close(); return EXIT_FAILURE; } if (varstrings.size() == 0) { std::cerr << "Warning: no variables specified" << std::endl; } std::vector<NcVar*> invars; for (std::vector<std::string>::const_iterator it = varstrings.begin(); it != varstrings.end(); ++it) { NcVar* var = infile.get_var((*it).c_str()); if (var == NULL) { std::cerr << "Error: " << *it << ": no such variable" << std::endl; infile.close(); outfile.close(); return EXIT_FAILURE; } invars.push_back(var); } // extract the distinct set of dims std::map<std::string, NcDim*> indims; for (std::vector<NcVar*>::const_iterator it = invars.begin(); it != invars.end(); ++it) { NcVar* var = *it; for (int i = 0; i < var->num_dims(); ++i) { NcDim* dim = var->get_dim(i); indims[dim->name()] = dim; } } // add dims to outfile std::map<std::string, NcDim*> outdims; for (std::map<std::string, NcDim*>::const_iterator it = indims.begin(); it != indims.end(); ++it) { NcDim* dim = (*it).second; NcDim* outdim = NULL; if (dim->is_unlimited()) { outdim = outfile.add_dim(dim->name()); } else { outdim = outfile.add_dim(dim->name(), dim->size()); } if (outdim != NULL) { outdims[outdim->name()] = outdim; } } // create variables for (std::vector<NcVar*>::const_iterator it = invars.begin(); it != invars.end(); ++it) { NcVar* var = *it; std::vector<const NcDim*> dims(var->num_dims()); for (int i = 0; i < var->num_dims(); ++i) { dims[i] = outdims[var->get_dim(i)->name()]; } NcVar* outvar = outfile.add_var(var->name(), var->type(), var->num_dims(), &dims[0]); // identify largest dim, if dim (nearly) exceeds main memory, split along that dim int maxdim = -1; long maxdimsize = 0; long totallen = 1; for (int i = 0; i < var->num_dims(); ++i) { NcDim* dim = var->get_dim(i); if (dim->size() > maxdimsize) { maxdim = i; maxdimsize = dim->size(); } totallen *= dim->size(); } // TODO: support other data types totallen *= sizeof(float); // TODO: configurable page size const unsigned long pagesize = 1000000000; #ifdef __linux__ struct sysinfo info; sysinfo(&info); if (pagesize >= info.freeram) { std::cerr << "Warning: page size exceeds free memory" << std::endl; } #endif int numpages = 1; long pagesizedim = var->get_dim(maxdim)->size(); if (totallen < pagesize) { } else { long mul = 1; for (int i = 0; i < var->num_dims(); ++i) { if (i != maxdim) { NcDim* dim = var->get_dim(i); mul *= dim->size(); } } // TODO: support other data types mul *= sizeof(float); pagesizedim = pagesize / mul; numpages = var->get_dim(maxdim)->size() / pagesizedim; if (var->get_dim(maxdim)->size() % pagesizedim > 0) { ++numpages; } } std::vector< std::vector<long> > curvec; std::vector< std::vector<long> > countsvec; std::vector<long> lengths; int pages = numpages > 0 ? numpages : 1; for (int p = 0; p < pages; ++p) { long len = 1; std::vector<long> cur; std::vector<long> counts; for (int i = 0; i < var->num_dims(); ++i) { NcDim* dim = var->get_dim(i); long current = 0; long count = dim->size(); if (i == maxdim) { current = pagesizedim * p; count = pagesizedim; if (p == pages -1) { if (dim->size() % pagesizedim != 0) { count = dim->size() % pagesizedim; } } } cur.push_back(current); counts.push_back(count); len *= count; } curvec.push_back(cur); countsvec.push_back(counts); lengths.push_back(len); } std::vector< std::vector<long> >::const_iterator it1; std::vector< std::vector<long> >::const_iterator it2; std::vector<long>::const_iterator it3; for (it1 = curvec.begin(), it2 = countsvec.begin(), it3 = lengths.begin(); it1 != curvec.end() && it2 != countsvec.end() && it3 != lengths.end(); ++it1, ++it2, ++it3) { std::vector<long> cur = *it1; std::vector<long> counts = *it2; long len = *it3; var->set_cur(&cur[0]); outvar->set_cur(&cur[0]); switch (outvar->type()) { case ncByte: { ncbyte* barr = new ncbyte[len]; var->get(barr, &counts[0]); outvar->put(barr, &counts[0]); delete[] barr; break; } case ncChar: { char* carr = new char[len]; var->get(carr, &counts[0]); outvar->put(carr, &counts[0]); delete[] carr; break; } case ncShort: { short* sarr = new short[len]; var->get(sarr, &counts[0]); outvar->put(sarr, &counts[0]); delete[] sarr; break; } case ncInt: { long* larr = new long[len]; var->get(larr, &counts[0]); outvar->put(larr, &counts[0]); delete[] larr; break; } case ncFloat: { float* farr = new float[len]; var->get(farr, &counts[0]); outvar->put(farr, &counts[0]); delete[] farr; break; } case ncDouble: { double* darr = new double[len]; var->get(darr, &counts[0]); outvar->put(darr, &counts[0]); delete[] darr; break; } default: break; } } } infile.close(); outfile.close(); return 0; }
const std::string name( void ) const { return( m_var->name() ); }
eavlNetCDFImporter::eavlNetCDFImporter(const string &filename) { file = new NcFile(filename.c_str(), NcFile::ReadOnly); if (!file->is_valid()) { THROW(eavlException,"Couldn't open file!\n"); } if (debugoutput) cerr << "num_dims="<<file->num_dims()<<endl; if (debugoutput) cerr << "num_vars="<<file->num_vars()<<endl; if (debugoutput) cerr << "num_atts="<<file->num_atts()<<endl; for (int i=0; i<file->num_dims(); i++) { NcDim *d = file->get_dim(i); if (debugoutput) cerr << " dim["<<i<<"]: name="<<d->name()<<" size="<<d->size()<<endl; } for (int i=0; i<file->num_atts(); i++) { NcAtt *a = file->get_att(i); if (debugoutput) cerr << " att["<<i<<"]: name="<<a->name()<<" numvals="<<a->num_vals()<<endl; } bool found_grid = false; for (int i=0; i<file->num_vars(); i++) { NcVar *v = file->get_var(i); if (debugoutput) { cerr << " var["<<i<<"]: name="<<v->name(); cerr << " ndims="<<v->num_dims(); cerr << " dims = "; for (int j=0; j<v->num_dims(); j++) { cerr << v->get_dim(j)->name(); if (j<v->num_dims()-1) cerr << "*"; } cerr << endl; } // Here's the condition for what we're going to use; // we only support one mesh for the moment, so we're picking one. // Also, the netcdf files we have have the time dim size as "1" if (v->num_dims() == 4 && string(v->get_dim(0)->name())=="time") { if (!found_grid) { dims.push_back(v->get_dim(1)); dims.push_back(v->get_dim(2)); dims.push_back(v->get_dim(3)); found_grid = true; vars.push_back(v); if (debugoutput) cerr << " * using as first real var\n"; } else { if (string(v->get_dim(1)->name()) == dims[0]->name() && string(v->get_dim(2)->name()) == dims[1]->name() && string(v->get_dim(3)->name()) == dims[2]->name()) { vars.push_back(v); if (debugoutput) cerr << " * using as another var; matches the first real one's dims\n"; } } } } }
bool EpidemicDataSet::loadNetCdfFile(const char * filename) { #if USE_NETCDF // TODO: should handle this differently // change netcdf library error behavior NcError err(NcError::verbose_nonfatal); // open the netcdf file NcFile ncFile(filename, NcFile::ReadOnly); if(!ncFile.is_valid()) { put_flog(LOG_FATAL, "invalid file %s", filename); return false; } // get dimensions NcDim * timeDim = ncFile.get_dim("time"); NcDim * nodesDim = ncFile.get_dim("nodes"); NcDim * stratificationsDim = ncFile.get_dim("stratifications"); if(timeDim == NULL || nodesDim == NULL || stratificationsDim == NULL) { put_flog(LOG_FATAL, "could not find a required dimension"); return false; } numTimes_ = timeDim->size(); // make sure we have the expected number of nodes if(nodesDim->size() != numNodes_) { put_flog(LOG_FATAL, "got %i nodes, expected %i", nodesDim->size(), numNodes_); return false; } put_flog(LOG_DEBUG, "file contains %i timesteps, %i nodes", numTimes_, numNodes_); // make sure number of stratifications matches our expectation... int numExpectedStratifications = 1; for(unsigned int i=0; i<NUM_STRATIFICATION_DIMENSIONS; i++) { numExpectedStratifications *= stratifications_[i].size(); } if(stratificationsDim->size() != numExpectedStratifications) { put_flog(LOG_FATAL, "got %i stratifications, expected %i", stratificationsDim->size(), numExpectedStratifications); return false; } // get all float variables with dimensions (time, nodes, stratifications) for(int i=0; i<ncFile.num_vars(); i++) { NcVar * ncVar = ncFile.get_var(i); if(ncVar->num_dims() == 3 && ncVar->type() == ncFloat && strcmp(ncVar->get_dim(0)->name(), "time") == 0 && strcmp(ncVar->get_dim(1)->name(), "nodes") == 0 && strcmp(ncVar->get_dim(2)->name(), "stratifications") == 0) { put_flog(LOG_INFO, "found variable: %s", ncVar->name()); // full shape blitz::TinyVector<int, 2+NUM_STRATIFICATION_DIMENSIONS> shape; shape(0) = numTimes_; shape(1) = numNodes_; for(int j=0; j<NUM_STRATIFICATION_DIMENSIONS; j++) { shape(2 + j) = stratifications_[j].size(); } blitz::Array<float, 2+NUM_STRATIFICATION_DIMENSIONS> var((float *)ncVar->values()->base(), shape, blitz::duplicateData); variables_[std::string(ncVar->name())].reference(var); } } #endif return true; }
bool NetworkObject::loadNetCDF(QString flnm) { m_fileName = flnm; NcError err(NcError::verbose_nonfatal); NcFile ncfFile(flnm.toLatin1().data(), NcFile::ReadOnly); NcAtt *att; NcVar *var; // ---- get gridsize ----- att = ncfFile.get_att("gridsize"); m_nX = att->as_int(0); m_nY = att->as_int(1); m_nZ = att->as_int(2); //------------------------ // ---- get vertex centers ----- var = ncfFile.get_var("vertex_centers"); if (!var) var = ncfFile.get_var("vertex_center"); if (!var) var = ncfFile.get_var("vertex_centres"); if (!var) var = ncfFile.get_var("vertex_centre"); int nv = var->get_dim(0)->size(); float *vc = new float [3*nv]; var->get(vc, nv, 3); m_vertexCenters.resize(nv); for(int i=0; i<nv; i++) m_vertexCenters[i] = Vec(vc[3*i+0], vc[3*i+1], vc[3*i+2]); delete [] vc; //------------------------ // ---- get edges ----- var = ncfFile.get_var("edge_neighbours"); int ne = var->get_dim(0)->size(); int *ed = new int [2*ne]; var->get(ed, ne, 2); m_edgeNeighbours.resize(ne); for(int i=0; i<ne; i++) m_edgeNeighbours[i] = qMakePair(ed[2*i], ed[2*i+1]); delete [] ed; //------------------------ Vec bmin = m_vertexCenters[0]; Vec bmax = m_vertexCenters[0]; for(int i=0; i<m_vertexCenters.count(); i++) { bmin = StaticFunctions::minVec(bmin, m_vertexCenters[i]); bmax = StaticFunctions::maxVec(bmax, m_vertexCenters[i]); } m_centroid = (bmin + bmax)/2; m_enclosingBox[0] = Vec(bmin.x, bmin.y, bmin.z); m_enclosingBox[1] = Vec(bmax.x, bmin.y, bmin.z); m_enclosingBox[2] = Vec(bmax.x, bmax.y, bmin.z); m_enclosingBox[3] = Vec(bmin.x, bmax.y, bmin.z); m_enclosingBox[4] = Vec(bmin.x, bmin.y, bmax.z); m_enclosingBox[5] = Vec(bmax.x, bmin.y, bmax.z); m_enclosingBox[6] = Vec(bmax.x, bmax.y, bmax.z); m_enclosingBox[7] = Vec(bmin.x, bmax.y, bmax.z); // QStringList vatt, eatt; int nvars = ncfFile.num_vars(); // for (int i=0; i < nvars; i++) // { // var = ncfFile.get_var(i); // QString attname = var->name(); // attname.toLower(); // if (attname.contains("vertex_") && // ( attname != "vertex_centers" || // attname != "vertex_centres")) // vatt.append(attname); // else if (attname.contains("edge_") && // attname != "edge_neighbours") // eatt.append(attname); // } m_vertexAttribute.clear(); m_edgeAttribute.clear(); m_vertexRadiusAttribute = -1; m_edgeRadiusAttribute = -1; int vri = 0; int eri = 0; for (int i=0; i < nvars; i++) { var = ncfFile.get_var(i); QString attname = var->name(); attname.toLower(); if (attname.contains("vertex_") && attname != "vertex_center" && attname != "vertex_centre" && attname != "vertex_centers" && attname != "vertex_centres") { if (attname == "vertex_radius") m_vertexRadiusAttribute = vri; vri++; QVector<float> val; val.clear(); if (var->type() == ncByte || var->type() == ncChar) { uchar *v = new uchar[nv]; var->get((ncbyte *)v, nv); for(int j=0; j<nv; j++) val.append(v[j]); delete [] v; } else if (var->type() == ncShort) { short *v = new short[nv]; var->get((short *)v, nv); for(int j=0; j<nv; j++) val.append(v[j]); delete [] v; } else if (var->type() == ncInt) { int *v = new int[nv]; var->get((int *)v, nv); for(int j=0; j<nv; j++) val.append(v[j]); delete [] v; } else if (var->type() == ncFloat) { float *v = new float[nv]; var->get((float *)v, nv); for(int j=0; j<nv; j++) val.append(v[j]); delete [] v; } if (val.count() > 0) m_vertexAttribute.append(qMakePair(attname, val)); } else if (attname.contains("edge_") && attname != "edge_neighbours") { if (attname == "edge_radius") m_edgeRadiusAttribute = eri; eri++; QVector<float> val; val.clear(); if (var->type() == ncByte || var->type() == ncChar) { uchar *v = new uchar[ne]; var->get((ncbyte *)v, ne); for(int j=0; j<ne; j++) val.append(v[j]); delete [] v; } else if (var->type() == ncShort) { short *v = new short[ne]; var->get((short *)v, ne); for(int j=0; j<ne; j++) val.append(v[j]); delete [] v; } else if (var->type() == ncInt) { int *v = new int[ne]; var->get((int *)v, ne); for(int j=0; j<ne; j++) val.append(v[j]); delete [] v; } else if (var->type() == ncFloat) { float *v = new float[ne]; var->get((float *)v, ne); for(int j=0; j<ne; j++) val.append(v[j]); delete [] v; } if (val.count() > 0) m_edgeAttribute.append(qMakePair(attname, val)); } } ncfFile.close(); if (!Global::batchMode()) { QString str; str = QString("Grid Size : %1 %2 %3\n").arg(m_nX).arg(m_nY).arg(m_nZ); str += QString("Vertices : %1\n").arg(m_vertexCenters.count()); str += QString("Edges : %1\n").arg(m_edgeNeighbours.count()); str += QString("\n"); str += QString("Vertex Attributes : %1\n").arg(m_vertexAttribute.count()); for(int i=0; i<m_vertexAttribute.count(); i++) str += QString(" %1\n").arg(m_vertexAttribute[i].first); str += QString("\n"); str += QString("Edge Attributes : %1\n").arg(m_edgeAttribute.count()); for(int i=0; i<m_edgeAttribute.count(); i++) str += QString(" %1\n").arg(m_edgeAttribute[i].first); QMessageBox::information(0, "Network loaded", str); } m_Vatt = 0; m_Eatt = 0; m_Vminmax.clear(); m_Eminmax.clear(); m_userVminmax.clear(); m_userEminmax.clear(); for(int i=0; i<m_vertexAttribute.count(); i++) { float vmin = m_vertexAttribute[i].second[0]; float vmax = m_vertexAttribute[i].second[0]; for(int j=1; j<m_vertexAttribute[i].second.count(); j++) { vmin = qMin((float)m_vertexAttribute[i].second[j], vmin); vmax = qMax((float)m_vertexAttribute[i].second[j], vmax); } m_Vminmax.append(qMakePair(vmin, vmax)); m_userVminmax.append(qMakePair((vmin+vmax)/2, vmax)); } for(int i=0; i<m_edgeAttribute.count(); i++) { float emin = m_edgeAttribute[i].second[0]; float emax = m_edgeAttribute[i].second[0]; for(int j=1; j<m_edgeAttribute[i].second.count(); j++) { emin = qMin((float)m_edgeAttribute[i].second[j], emin); emax = qMax((float)m_edgeAttribute[i].second[j], emax); } m_Eminmax.append(qMakePair(emin, emax)); m_userEminmax.append(qMakePair((emin+emax)/2, emax)); } return true; }
vtkDataArray * avtS3DFileFormat::GetVar(int timeState, int domain, const char *varname) { debug5 << "avtS3DFileFormat::GetVar( timeState=" << timeState << ", domain=" << domain << ", varname=" << varname << ")" << endl; // Calculate the timestep directory that the data lives in. char *pathcopy = strdup(mainFilename); string dir = parse_dirname(pathcopy); string timestepDir = CreateStringFromDouble(fileTimes[timeState]); debug4 << "Timestep directory is <" << timestepDir << ">" << endl; // Figure out how big this piece is. CalculateSubpiece(domain); // Open up the NetCDF file. char path[256]; SNPRINTF(path,256,"%s%s%s%sfield.%05d",dir.c_str(),VISIT_SLASH_STRING, timestepDir.c_str(), VISIT_SLASH_STRING, domain); debug5 << "avtS3DFileFormat::GetVar: Full path to data file is " << path << endl; NcFile nf(path); if (!nf.is_valid()) { debug1 << nc_strerror(NcError().get_err()) << endl; EXCEPTION1(InvalidFilesException, path); } debug5 << "avtS3DFileFormat::GetVar: Got valid file." << endl; // Pull out the appropriate variable. NcVar *v = nf.get_var(varname); if (!v) { debug1 << nc_strerror(NcError().get_err()) << endl; EXCEPTION1(InvalidVariableException, varname); } // Check if it fits the size of the mesh. Always node-centered, remember. int ntuples = localDims[0] * localDims[1] * localDims[2]; debug5 << "ntuples:" << ntuples << endl; int nvals = v->num_vals(); if (ntuples != nvals) { debug1 << "The variable " << v->name() << " does not conform to its mesh (" << nvals << " != " << ntuples << ")" << endl; EXCEPTION1(InvalidVariableException, v->name()); } // Set up the VTK dataset. vtkFloatArray *rv = vtkFloatArray::New(); rv->SetNumberOfTuples(ntuples); float *p = (float*)rv->GetVoidPointer(0); NcValues *input = v->values(); if (!input) { debug1 << nc_strerror(NcError().get_err()) << endl; EXCEPTION1(InvalidVariableException, v->name()); } // Get the scaling factor. NcAtt *scaling = v->get_att(NcToken("scale_factor")); float scaling_factor = 1; if (scaling) { scaling_factor = scaling->as_float(0); debug5 << "avtS3DFileFormat::GetVar: Set the scaling factor as " << scaling_factor << endl; } // Process the variable into the returned data. float *base = (float*)input->base(); for(int i=0;i<ntuples;i++) { p[i] = *(base + i) * scaling_factor; } return rv; }
void avtS3DFileFormat::PopulateDatabaseMetaData(avtDatabaseMetaData *md, int timeState) { debug5 << "avtS3DFileFormat::PopulateDatabaseMetaData" << endl; // Get the metadata from the log file first. OpenLogFile(); // Mesh avtMeshMetaData *mesh = new avtMeshMetaData; mesh->name = "mesh"; mesh->meshType = AVT_RECTILINEAR_MESH; mesh->numBlocks = procs[0] * procs[1] * procs[2]; mesh->blockOrigin = 1; mesh->cellOrigin = 0; mesh->spatialDimension = 3; mesh->topologicalDimension = 3; mesh->blockTitle = "blocks"; mesh->blockPieceName = "block"; mesh->hasSpatialExtents = false; mesh->xUnits = "mm"; mesh->yUnits = "mm"; mesh->zUnits = "mm"; md->Add(mesh); // // Look in the NetCDF file for the first block for the list of variables. // // Calculate the timestep directory that the data lives in. char *pathcopy = strdup(mainFilename); string dir = parse_dirname(pathcopy); string timestepDir = CreateStringFromDouble(fileTimes[timeState]); char path[256]; SNPRINTF(path,256,"%s%s%s%sfield.00000",dir.c_str(),VISIT_SLASH_STRING, timestepDir.c_str(), VISIT_SLASH_STRING); NcError err(NcError::verbose_nonfatal); NcFile nf(path); if (!nf.is_valid()) { EXCEPTION1(InvalidFilesException, path); } debug5 << "avtS3DFileFormat::PopulateDatabaseMetaData: Got valid file" << endl; int nvars = nf.num_vars(); debug5 << "avtS3DFileFormat::PopulateDatabaseMetaData: Found " << nvars << " variables" << endl; for (int i=0 ; i<nvars; i++) { NcVar *v = nf.get_var(i); if (!v) continue; debug4 << "Found variable " << v->name() << endl; // Check dimensionality int nvals = v->num_vals(); if (nvals != 1) // Single scalars are useless. { avtScalarMetaData *scalar = new avtScalarMetaData(); scalar->name = v->name(); scalar->meshName = "mesh"; scalar->centering = AVT_NODECENT; scalar->hasDataExtents = false; scalar->treatAsASCII = false; NcAtt *units = v->get_att(NcToken("units")); if (units) { long nv = units->num_vals(); if (nv == 0) { scalar->hasUnits = false; } else { char *unitString = units->as_string(0); scalar->units = unitString; scalar->hasUnits = true; } } else scalar->hasUnits = false; md->Add(scalar); } else { debug4 << "Unable to process variable " << v->name() << " since it is a single scalar" << endl; } } #if 0 // Expressions Expression tempGradient_expr; tempGradient_expr.SetName("Temperature_gradient"); tempGradient_expr.SetDefinition("gradient(Temperature)"); tempGradient_expr.SetType(Expression::VectorMeshVar); tempGradient_expr.SetHidden(true); md->AddExpression(&tempGradient_expr); Expression tempUnit_expr; tempUnit_expr.SetName("Temperature_grad_unit"); //tempUnit_expr.SetDefinition("(Temperature_gradient + {1e-6,0,0})/(magnitude(Temperature_gradient) + 1e-6)"); //tempUnit_expr.SetDefinition("Temperature_gradient/(magnitude(Temperature_gradient) + 1e-6)"); tempUnit_expr.SetDefinition("normalize(Temperature_gradient)"); tempUnit_expr.SetType(Expression::VectorMeshVar); tempUnit_expr.SetHidden(true); md->AddExpression(&tempUnit_expr); Expression tempCurv_expr; tempCurv_expr.SetName("Temperature_curvature"); tempCurv_expr.SetDefinition("divergence(Temperature_grad_unit)"); tempCurv_expr.SetType(Expression::ScalarMeshVar); tempUnit_expr.SetHidden(false); md->AddExpression(&tempCurv_expr); #endif }