void NetCdfConfigureDialog::getDimEdges(int dimId, unsigned &size, double &firstValue, double &lastValue)
{
if ((_currentFile->get_var(_currentVar->get_dim(dimId)->name())) != NULL)
{
NcVar *tmpVarOfDim = _currentFile->get_var(_currentVar->get_dim(dimId)->name());
if ((tmpVarOfDim->num_dims()) == 1)
{
int sizeOfDim = tmpVarOfDim->get_dim(0)->size();
size = sizeOfDim;
double arrayOfDimStart[1] = {0};
size_t edgeOfArray[1] = {1};
long edgeOrigin[1] = {0};
tmpVarOfDim->set_cur(edgeOrigin);
tmpVarOfDim->get(arrayOfDimStart,edgeOfArray);
firstValue = arrayOfDimStart[0];
double arrayOfDimEnd[1] = {0};
edgeOrigin[0] = sizeOfDim - 1;
tmpVarOfDim->set_cur(edgeOrigin);
tmpVarOfDim->get(arrayOfDimEnd,edgeOfArray);
lastValue = arrayOfDimEnd[0];
}
} else {
size = 0;
firstValue = 0;
lastValue = 0;
}
}
void InputNetcdf::getLocationsCore(std::vector<Location>& iLocations) const {
iLocations.clear();
std::string filename = getLocationFilename();
NcFile ncfile(filename.c_str());
if(ncfile.is_valid()) {
NcDim* ncLocationDim = ncfile.get_dim("Location");
int numLocations = ncLocationDim->size();
NcVar* ncLats = ncfile.get_var("Lat");
NcVar* ncLons = ncfile.get_var("Lon");
NcError q(NcError::silent_nonfatal);
NcVar* ncElevs = ncfile.get_var("Elev");
NcVar* ncIds = ncfile.get_var("Id");
bool hasId = false;
bool hasElev = false;
if(ncIds)
hasId = true;
if(ncElevs)
hasElev = true;
float* lats = new float[numLocations];
float* lons = new float[numLocations];
float* elevs = new float[numLocations];
int* ids = new int[numLocations];
long count[1] = {numLocations};
ncLats->get(lats, count);
ncLons->get(lons, count);
if(hasId)
ncIds->get(ids, count);
if(hasElev)
ncElevs->get(elevs, count);
for(int i = 0; i < numLocations; i++) {
int id = i;
if(hasId)
id = ids[i];
float lat = lats[i];
float lon = lons[i];
float elev = Global::MV;
if(hasElev)
elev = elevs[i];
Location loc(getName(), id, lat, lon);
loc.setElev(elev);
iLocations.push_back(loc);
}
delete[] lats;
delete[] lons;
delete[] elevs;
delete[] ids;
ncfile.close();
}
else {
notifyInvalidSampleFile();
}
}
void LoadMetaDataFile(
const std::string & strInputMeta,
DataMatrix3D<int> & dataGLLNodes,
DataMatrix3D<double> & dataGLLJacobian
) {
NcFile ncMeta(strInputMeta.c_str(), NcFile::ReadOnly);
NcDim * dimNp = ncMeta.get_dim("np");
if (dimNp == NULL) {
_EXCEPTIONT("Dimension \"np\" missing from metadata file");
}
NcDim * dimNelem = ncMeta.get_dim("nelem");
if (dimNelem == NULL) {
_EXCEPTIONT("Dimension \"nelem\" missing from metadata file");
}
NcVar * varGLLNodes = ncMeta.get_var("GLLnodes");
if (dimNelem == NULL) {
_EXCEPTIONT("Variable \"GLLnodes\" missing from metadata file");
}
NcVar * varGLLJacobian = ncMeta.get_var("J");
if (dimNelem == NULL) {
_EXCEPTIONT("Variable \"J\" missing from metadata file");
}
int nP = dimNp->size();
int nElem = dimNelem->size();
DataMatrix3D<int> dataGLLNodes_tmp;
DataMatrix3D<double> dataGLLJacobian_tmp;
dataGLLNodes.Initialize(nP, nP, nElem);
dataGLLJacobian.Initialize(nP, nP, nElem);
dataGLLNodes_tmp.Initialize(nP, nP, nElem);
dataGLLJacobian_tmp.Initialize(nP, nP, nElem);
varGLLNodes->get(&(dataGLLNodes_tmp[0][0][0]), nP, nP, nElem);
varGLLJacobian->get(&(dataGLLJacobian_tmp[0][0][0]), nP, nP, nElem);
for (int i = 0; i < nP; i++) {
for (int j = 0; j < nP; j++) {
for (int k = 0; k < nElem; k++) {
dataGLLNodes[i][j][k] = dataGLLNodes_tmp[j][i][k];
dataGLLJacobian[i][j][k] = dataGLLJacobian_tmp[j][i][k];
}
}
}
}
FileArome::FileArome(std::string iFilename, bool iReadOnly) : FileNetcdf(iFilename, iReadOnly) {
// Set dimensions
NcDim* dTime = getDim("time");
NcDim* dLon = getDim("x");
NcDim* dLat = getDim("y");
mNTime = dTime->size();
mNLat = dLat->size();
mNLon = dLon->size();
mNEns = 1;
mLats = getLatLonVariable("latitude");
mLons = getLatLonVariable("longitude");
if(hasVariableCore("surface_geopotential")) {
FieldPtr elevField = getFieldCore("surface_geopotential", 0);
mElevs.resize(getNumLat());
for(int i = 0; i < getNumLat(); i++) {
mElevs[i].resize(getNumLon());
for(int j = 0; j < getNumLon(); j++) {
float value = (*elevField)(i,j,0) / 9.81;
mElevs[i][j] = value;
}
}
std::cout << "Deriving altitude from geopotential height in " << getFilename() << std::endl;
}
else {
mElevs = getLatLonVariable("altitude");
}
if(hasVar("time")) {
NcVar* vTime = getVar("time");
double* times = new double[mNTime];
vTime->get(times , mNTime);
setTimes(std::vector<double>(times, times+mNTime));
delete[] times;
}
else {
std::vector<double> times;
times.resize(getNumTime(), Util::MV);
setTimes(times);
}
if(hasVar("forecast_reference_time")) {
NcVar* vReferenceTime = getVar("forecast_reference_time");
double referenceTime = getReferenceTime();
vReferenceTime->get(&referenceTime, 1);
setReferenceTime(referenceTime);
}
Util::status( "File '" + iFilename + " 'has dimensions " + getDimenionString());
}
template<class T> static bool load_nc_array(const NcFile& ncf, const string& name, vector<T>& dest, bool required = true, int offset = 0, int count = -1)
{
NcVar *v = load_nc_variable(ncf, name.c_str(), required);
if (v)
{
vector<long> offsets = list_of(offset).repeat(v->num_dims()-1, 0);
v->set_cur(&offsets.front());
vector<long> counts (v->num_dims());
long* shape = v->edges();
transform(shape, shape + v->num_dims(), offsets.begin(), counts.begin(), minus<long>());
delete shape;
if (count > 0)
{
counts[0] = count;
}
dest.resize(product(counts));
bool success = v->get(&dest.front(), &counts.front());
if (!success)
{
dest.resize(0);
check(!required, string("NetcdfDataset::load_nc_array<") + typeid(T).name() + "> " + name + '\n' + "failed with offset " + str(offsets) + ", counts " + str(counts));
}
return success;
}
return false;
}
FieldPtr FileArome::getFieldCore(std::string iVariable, int iTime) const {
// Not cached, retrieve data
NcVar* var = getVar(iVariable);
int nLat = mNLat;
int nLon = mNLon;
int numDims = var->num_dims();
long* count;
long totalCount = nLat*nLon;
if(numDims == 4) {
// Variable has a surface dimension
count = new long[4];
count[0] = 1;
count[1] = 1;
count[2] = nLat;
count[3] = nLon;
var->set_cur(iTime, 0, 0, 0);
}
else if(numDims == 3) {
count = new long[3];
count[0] = 1;
count[1] = nLat;
count[2] = nLon;
var->set_cur(iTime, 0, 0);
}
else {
std::stringstream ss;
ss << "Cannot read variable '" << iVariable << "' from '" << getFilename() << "'";
Util::error(ss.str());
}
float* values = new float[nLat*nLon];
var->get(values, count);
float MV = getMissingValue(var);
float offset = getOffset(var);
float scale = getScale(var);
int index = 0;
FieldPtr field = getEmptyField();
for(int lat = 0; lat < nLat; lat++) {
for(int lon = 0; lon < nLon; lon++) {
float value = values[index];
assert(index < totalCount);
if(value == MV) {
// Field has missing value indicator and the value is missing
// Save values using our own internal missing value indicator
value = Util::MV;
}
else {
value = scale*values[index] + offset;
}
(*field)(lat,lon,0) = value;
index++;
}
}
delete[] values;
delete[] count;
return field;
}
int NetcdfSource::readScalar(double *v, const QString& field)
{
// TODO error handling
QByteArray bytes = field.toLatin1();
NcVar *var = _ncfile->get_var(bytes.constData()); // var is owned by _ncfile
var->get(v);
return 1;
}
void InputRdaNetcdf::getLocationsCore(std::vector<Location>& iLocations) const {
std::string filename = getLocationFilename();
NcFile ncfile(filename.c_str());
assert(ncfile.is_valid());
NcVar* ncLats = ncfile.get_var("latitude");
NcVar* ncLons = ncfile.get_var("longitude");
NcVar* ncElevs = ncfile.get_var("altitude");
NcVar* ncNames = ncfile.get_var("station_id");
NcDim* ncNamesDim = ncfile.get_dim("id_len");
int namesLength = ncNamesDim->size();
NcDim* ncLocationDim = ncfile.get_dim("station");
int numLocations = ncLocationDim->size();
float* lats = new float[numLocations];
float* lons = new float[numLocations];
float* elevs = new float[numLocations];
char* names = new char[numLocations*namesLength];
long count[2] = {numLocations, namesLength};
ncLats->get(lats, count);
ncLons->get(lons, count);
ncElevs->get(elevs, count);
ncNames->get(names, count);
iLocations.resize(numLocations);
for(int i = 0; i < numLocations; i++) {
int id = i;
float lat = lats[i];
float lon = lons[i];
float elev = elevs[i];
Location loc(getName(), id, lat, lon);
loc.setElev(elev);
iLocations[i] = loc;
int nameIndex = i*namesLength;
std::string name = std::string(&names[nameIndex], namesLength);
mLocationNames[name] = i;
}
delete[] lats;
delete[] lons;
delete[] elevs;
delete[] names;
ncfile.close();
}
std::vector<T> read_vector(NcFile &nc, std::string const &var_name)
{
// Read points vector
NcVar *vpoints = nc.get_var(var_name.c_str());
long npoints = vpoints->get_dim(0)->size();
std::vector<T> points(npoints);
vpoints->get(&points[0], npoints);
return points;
}
ERMsg C20thReanalysisProject::ReadData( CString filePath, CString varName, CData3Array& data)
{
//typedef boost::multi_array<int, 2> array_type;
ERMsg msg;
NcError::set_err( NcError::silent_nonfatal );
//CString filePath = m_path + "cccma_cgcm3_1-20c3m-run1-pr-1961-2000_monthly.nc";//GetFilePath(v, year, m);
NcFile file(filePath); //current year file
if( !file.is_valid() )
{
CString err;
err.FormatMessage(IDS_CMN_UNABLE_OPEN_READ, filePath);
msg.ajoute(err);
return msg;
}
NcVar* pVarData = file.get_var((LPCTSTR)varName);//is the varaible always at ffirst???
//CString varName = pVarData->name();
size_t sizeTime = pVarData->get_dim(0)->size();
size_t sizeY = pVarData->get_dim(1)->size();
size_t sizeX = pVarData->get_dim(2)->size();
float offset = pVarData->get_att("add_offset")->as_float(0);
float scaleFactor = pVarData->get_att("scale_factor")->as_float(0);
boost::multi_array<short, 3> tmp(boost::extents[sizeTime][sizeY][sizeX]);
ENSURE( pVarData->num_dims() == 3);
if( pVarData->get(&(tmp[0][0][0]), sizeTime, sizeY, sizeX) )
{
//tmp.extens()
//data.resize(sizeTime);
//data.resize(boost::extents[sizeTime][sizeY][sizeX]);
//apply offset and scale factor
for(size_t i=0; i<tmp.size(); i++)
for(size_t j=0; j<tmp[i].size(); j++)
for(size_t k=0; k<tmp[i][j].size(); k++)
data[i][j][k] = tmp[i][j][k]*scaleFactor+offset;
file.close();
}
else
{
msg.ajoute( "Unable to get NetCDFData");
}
return msg;
}
int main(int argc, char *argv[])
{
NcFile at(atpath, NcFile::ReadOnly);
if(!at.is_valid() || at.num_dims() != 3 || at.num_vars() != 4) {
fprintf(stderr, "failed reading file: %s\n", atpath);
return 1;
}
NcVar* data = at.get_var("rhum");
if(!data->is_valid() || data->num_dims() != 3) {
fprintf(stderr, "rhum has incorrect dimensions");
return 1;
}
NcDim* time = data->get_dim(0);
int timecnt = time->size();
float *rhumd = new float[timecnt*LATS*LONS];
data->get(rhumd, timecnt, LATS, LONS);
float rhumdmon[12][LATS][LONS];
for(int i = 0; i<LATS; i++)
for(int j = 0; j<LONS; j++) {
float rhumdmoncnt[12];
for(int k = 0; k<12; k++) {
rhumdmon[k][i][j] = 0;
rhumdmoncnt[k] = 0;
}
for(int k = 0; k<timecnt; k++) {
double v = rhumd[(k*LATS+i)*LONS+j]*.1 + 3276.5;
if(v >= 0 && v <= 100) {
rhumdmon[k%12][i][j] += v;
rhumdmoncnt[k%12]++;
}
}
for(int k = 0; k<12; k++)
rhumdmon[k][i][j] /= rhumdmoncnt[k];
}
delete [] rhumd;
/* use a single byte instead of 2 to save memory,
resolution of 1/5th of a mm/day resolution */
uint8_t rhumbyte[12][LATS][LONS];
for(int i = 0; i<12; i++)
for(int j = 0; j<LATS; j++)
for(int k = 0; k<LONS; k++)
if(isnan(rhumdmon[i][j][k]) || fabs(rhumdmon[i][j][k]) > 100)
rhumbyte[i][j][k] = 255;
else
rhumbyte[i][j][k] = rhumdmon[i][j][k]*2.0;
fwrite(rhumbyte, sizeof rhumbyte, 1, stdout);
return 0;
}
//YUAN: recid - the order (from ZERO) in the .nc file, chtid - the cohort id
int SiteinInputer::getRecID(const int &siteid){
NcError err(NcError::silent_nonfatal);
NcFile siteFile(siteinfname.c_str(), NcFile::ReadOnly);
NcVar* siteidV = siteFile.get_var("CHTID");
int id = -1;
for (int i=0; i<(int)siteidV->num_vals(); i++){
siteidV->set_cur(i);
siteidV->get(&id, 1);
if(id==siteid) return i;
}
return -1;
}
int main(void)
{
try
{
// This is the array we will read.
int dataIn[NX][NY];
// Open the file. The ReadOnly parameter tells netCDF we want
// read-only access to the file.
NcFile dataFile("simple_xy.nc", NcFile::ReadOnly);
// You should always check whether a netCDF file open or creation
// constructor succeeded.
// if (!dataFile.is_valid())
// {
// cout << "Couldn't open file!\n";
// return NC_ERR;
// }
// For other method calls, the default behavior of the C++ API is
// to exit with a message if there is an error. If that behavior
// is OK, there is no need to check return values in simple cases
// like the following.
// Retrieve the variable named "data"
NcVar *data = dataFile.getVar("data");
// Read all the values from the "data" variable into memory.
data->get(&dataIn[0][0], NX, NY);
// Check the values.
for (int i = 0; i < NX; i++)
for (int j = 0; j < NY; j++)
if (dataIn[i][j] != i * NY + j)
return NC_ERR;
// The netCDF file is automatically closed by the NcFile destructor
cout << "*** SUCCESS reading example file simple_xy.nc!" << endl;
return 0;
}catch(NcException e)
{
e.what();
cout<<"FAILURE*************************************"<<endl;
return 1;
}
}
void Regioner::createCohorList4Run(){
// read in a list of cohorts to run
//netcdf error
NcError err(NcError::silent_nonfatal);
//open file and check if valid
string filename = md.runchtfile;
NcFile runFile(filename.c_str(), NcFile::ReadOnly);
if(!runFile.is_valid()){
string msg = filename+" is not valid";
char* msgc = const_cast< char* > ( msg.c_str());
throw Exception(msgc, I_NCFILE_NOT_EXIST);
}
NcDim* chtD = runFile.get_dim("CHTID");
if(!chtD->is_valid()){
string msg="CHT Dimension is not valid in createCohortList4Run";
char* msgc = const_cast<char*> (msg.c_str());
throw Exception(msgc, I_NCDIM_NOT_EXIST);
}
NcVar* chtV = runFile.get_var("CHTID");
if(chtV==NULL){
string msg="Cannot get CHTID in createCohortList4Run ";
char* msgc = const_cast<char*> (msg.c_str());
throw Exception(msgc, I_NCVAR_NOT_EXIST);
}
int numcht = chtD->size();
int chtid = -1;
int chtid0 = -1;
int chtidx = -1;
for (int i=0; i<numcht; i++){
chtV->set_cur(i);
chtV->get(&chtid, 1);
runchtlist.push_back(chtid);
if (i==0) chtid0=chtid;
if (i==numcht-1) chtidx=chtid;
}
cout <<md.casename << ": " <<numcht <<" cohorts to be run @" <<md.runstages<< "\n";
cout <<" from: " <<chtid0<<" to: " <<chtidx <<"\n";
};
int NetcdfSource::readMatrix(double *v, const QString& field)
{
/* For a variable from the netCDF file */
QByteArray bytes = field.toLatin1();
NcVar *var = _ncfile->get_var(bytes.constData()); // var is owned by _ncfile
if (!var) {
KST_DBG qDebug() << "Queried field " << field << " which can't be read" << endl;
return -1;
}
int xSize = var->get_dim(0)->size();
int ySize = var->get_dim(1)->size();
var->get(v, xSize, ySize);
return xSize * ySize;
}
CCatchmentSetupParams::CCatchmentSetupParams(const std::string & szFilenameForCatchment)
{
if(!boost::filesystem::exists(szFilenameForCatchment))
throw "szFilenameForCatchment doesn't exist";
pCatchmentDescriptionFile = new NcFile(szFilenameForCatchment.c_str());
if (!pCatchmentDescriptionFile->is_valid())
{
throw "Couldn't open file!";
}
NcVar * pReachIDs = pCatchmentDescriptionFile->get_var("rchid");
NcDim* numReaches = pReachIDs->get_dim(0);
const int nNumReaches = numReaches->size();
cout << "numReaches=" << nNumReaches << endl;
//std::vector<int> aReachIDs(nNumReaches, -1);
int anReaches[nNumReaches];
pReachIDs->get(anReaches, nNumReaches); //This is the mapping from rchid to nrch (=idx)
for(int nrch=0;nrch<nNumReaches;nrch++)
{
std::cout << "Reach: " << anReaches[nrch] << std::endl;
aSubcatchments[nrch] = new CSubcatchmentParams(nrch, anReaches[nrch], this);
}
int anDownstreamReaches[nNumReaches];
pCatchmentDescriptionFile->get_var("dsrch_nrch")->get(anDownstreamReaches, nNumReaches);
for(int nrch=0;nrch<nNumReaches;nrch++)
{
if(anDownstreamReaches[nrch]>=0)
{
std::cout << "Catchment " << nrch << " Downstream reach: " << anDownstreamReaches[nrch] << std::endl;
//aSubcatchments[nrch] = new CSubcatchmentParams(nrch, this);
aSubcatchments[nrch]->setDownstreamCatchment(aSubcatchments[anDownstreamReaches[nrch]]);
}
}
std::cout << std::endl;
}
float * readNetCdfFile(string fileName, string dataName, string xDimension, string yDimension)
{
NcFile file(fileName.c_str(), NcFile::ReadOnly);
if (!file.is_valid())
{
cout << "Couldn't open file!\n";
throw;
}
NcVar *experimentData = file.get_var(dataName.c_str());
dataYsize = file.get_dim(yDimension.c_str())->size();
dataXsize = file.get_dim(xDimension.c_str())->size();
float * data = new float[dataYsize * dataXsize];;
experimentData->get(&data[0], dataYsize, dataXsize);
return data;
}
void InputNetcdf::getOffsetsCore(std::vector<float>& iOffsets) const {
iOffsets.clear();
std::string filename = getSampleFilename();
NcFile ncfile(filename.c_str());
if(ncfile.is_valid()) {
NcDim* ncOffsetDim = ncfile.get_dim("Offset");
int numOffsets = ncOffsetDim->size();
NcVar* ncOffsets = ncfile.get_var("Offset");
float* offsets = new float[numOffsets];
//float* elevs = new float[numOffsets];
long count[1] = {numOffsets};
ncOffsets->get(offsets, count);
for(int i = 0; i < numOffsets; i++) {
iOffsets.push_back(offsets[i]);
}
delete[] offsets;
ncfile.close();
}
else {
notifyInvalidSampleFile();
}
}
vec2 FileArome::getLatLonVariable(std::string iVar) const {
NcVar* var = getVar(iVar);
float MV = getMissingValue(var);
long count[2] = {getNumLat(), getNumLon()};
float* values = new float[getNumLon()*getNumLat()];
var->get(values, count);
vec2 grid;
grid.resize(getNumLat());
for(int i = 0; i < getNumLat(); i++) {
grid[i].resize(getNumLon());
for(int j = 0; j < getNumLon(); j++) {
int index = i*getNumLon() + j;
float value = values[index];
if(values[index] == MV)
value = Util::MV;
grid[i][j] = value;
assert(index < getNumLon()*getNumLat());
}
}
delete[] values;
return grid;
}
void InputNetcdf::getMembersCore(std::vector<Member>& iMembers) const {
iMembers.clear();
std::string filename = getSampleFilename();
NcFile ncfile(filename.c_str());
if(ncfile.is_valid()) {
NcDim* ncMemberDim = ncfile.get_dim("Member");
int numMembers = ncMemberDim->size();
NcVar* ncRes = ncfile.get_var("Resolution");
float* res = new float[numMembers];
long count[1] = {numMembers};
ncRes->get(res, count);
for(int i = 0; i < numMembers; i++) {
Member member(getName(), res[i], "", i);
iMembers.push_back(member);
}
delete[] res;
ncfile.close();
}
else {
notifyInvalidSampleFile();
}
}
static string get_nc_string(const NcFile& ncf, const string& name, int offset = 0, bool required = true)
{
static array<long, 2> offsets = {{0, 0}};
static array<long, 2> counts = {{1, 0}};
NcVar *v = load_nc_variable(ncf, name.c_str(), required);
if (v)
{
long* shape = v->edges();
offsets.front() = offset;
counts.back() = shape[1];
v->set_cur(&offsets.front());
char* temp = new char [shape[1]];
delete shape;
bool success = v->get(temp, &counts.front());
if(!success)
{
check(!required, " index " + str(offset) + " out of bounds for " + name + " in netcdf file");
}
string s(temp);
delete [] temp;
return s;
}
return "";
}
blitz::Array<T,rank> read_blitz(NcFile &nc, std::string const &var_name)
{
// Read points vector
NcVar *vpoints = nc.get_var(var_name.c_str());
int ndims = vpoints->num_dims();
if (ndims != rank) {
fprintf(stderr, "NetCDF variable %s has rank %d, expected rank %d\n",
var_name.c_str(), ndims, rank);
throw std::exception();
}
blitz::TinyVector<int,rank> shape(0);
long counts[rank];
for (int i=0; i<rank; ++i) {
shape[i] = vpoints->get_dim(i)->size();
printf("read_blitz: shape[%d] = %d\n", i, shape[i]);
counts[i] = shape[i];
}
blitz::Array<T,rank> ret(shape);
for (int i=0; i<rank; ++i) printf("read_blitz: ret.extent(%d) = %d\n", i, ret.extent(i));
vpoints->get(ret.data(), counts);
return ret;
}
RadarData_t ReadRadarFile(const string &filename,
const float latmin, const float latmax,
const float lonmin, const float lonmax)
{
RadarData_t inputData;
// Sets the internal netcdf error handling to nonfatal for this scope
NcError error_handler(NcError::verbose_nonfatal);
NcFile radarFile(filename.c_str());
if (!radarFile.is_valid())
{
cerr << "ERROR: Could not open radar file: " << filename << " for reading.\n";
// Error is indicated by the lack of initialization of
// the filename member of the struct.
return(inputData);
}
NcVar* latVar = radarFile.get_var("lat");
if (NULL == latVar)
{
cerr << "ERROR: invalid data file. No variable called 'lat'!\n";
radarFile.close();
return(inputData);
}
long latCnt = latVar->num_vals();
double* latVals = new double[latCnt];
latVar->get(latVals, latCnt);
inputData.latUnits = GrabAttribute(latVar, 0);
inputData.latSpacing = strtod(GrabAttribute(latVar, 1).c_str(), NULL);
const long minLatIndex = lower_bound(latVals, latmin, latCnt);
const long maxLatIndex = upper_bound(latVals, latmax, latCnt);
delete latVals;
latCnt = (maxLatIndex - minLatIndex) + 1;
latVar->set_cur(minLatIndex);
inputData.latVals = new double[latCnt];
latVar->get(inputData.latVals, latCnt);
NcVar* lonVar = radarFile.get_var("lon");
if (NULL == lonVar)
{
cerr << "ERROR: invalid data file. No variable called 'lon'!\n";
radarFile.close();
return(inputData);
}
long lonCnt = lonVar->num_vals();
double* lonVals = new double[lonCnt];
lonVar->get(lonVals, lonCnt);
inputData.lonUnits = GrabAttribute(lonVar, 0);
inputData.lonSpacing = strtod(GrabAttribute(lonVar, 1).c_str(), NULL);
const long minLonIndex = lower_bound(lonVals, lonmin, lonCnt);
const long maxLonIndex = upper_bound(lonVals, lonmax, lonCnt);
delete lonVals;
lonCnt = (maxLonIndex - minLonIndex) + 1;
lonVar->set_cur(minLonIndex);
inputData.lonVals = new double[lonCnt];
lonVar->get(inputData.lonVals, lonCnt);
NcVar* reflectVar = NULL;
reflectVar = radarFile.get_var("value");
if ( reflectVar == NULL )
{
// Try this variable name
reflectVar = radarFile.get_var("Reflectivity");
}
if (reflectVar == NULL)
{
cerr << "ERROR: invalid data file. No variable called 'value'!\n";
radarFile.close();
return(inputData);
}
inputData.dataEdges = reflectVar->edges(); // [0] - time, [1] - lat, [2] - lon
inputData.dataEdges[1] = latCnt;
inputData.dataEdges[2] = lonCnt;
inputData.dataVals = new double[inputData.dataEdges[0] * inputData.dataEdges[1] * inputData.dataEdges[2]];
reflectVar->set_cur(0, minLatIndex, minLonIndex);
reflectVar->get(inputData.dataVals, inputData.dataEdges);
inputData.var_LongName = GrabAttribute(reflectVar, 0);
inputData.var_Units = "dBZ";//GrabAttribute(reflectVar, 1);
NcVar* timeVar = radarFile.get_var("time");
if (NULL == timeVar)
{
cerr << "ERROR: invalid data file. No variable called 'time'!\n";
radarFile.close();
return(inputData);
}
inputData.scanTime = timeVar->as_long(0);
inputData.timeUnits = GrabAttribute(timeVar, 0);
NcAtt* titleAttrib = radarFile.get_att("title");
inputData.fileTitle = (NULL == titleAttrib ? "" : titleAttrib->as_string(0));
delete titleAttrib;
radarFile.close();
// Success!
inputData.inputFilename = filename;
return(inputData);
}
float InputRdaNetcdf::getValueCore(const Key::Input& iKey) const {
float returnValue = Global::MV;
std::string filename = getFilename(iKey);
NcFile ncfile(filename.c_str());
std::string localVariable;
bool found = getLocalVariableName(iKey.variable, localVariable);
assert(found);
Key::Input key = iKey;
// Pre-fill incase file does not contain some keys
std::vector<float> offsets = getOffsets();
const std::vector<Location>& locations = getLocations();
for(int o = 0; o < offsets.size(); o++) {
key.offset = offsets[o];
for(key.location = 0; key.location < locations.size(); key.location++) {
if((mCacheOtherOffsets || iKey.offset == key.offset) ||
(mCacheOtherLocations || iKey.location == key.location)) {
Input::addToCache(key, Global::MV);
}
}
}
if(ncfile.is_valid() && localVariable != "") {
// Record data
NcVar* ncvar = ncfile.get_var(localVariable.c_str());
NcVar* ncTimes = ncfile.get_var("time_observation");
NcVar* ncStationIds = ncfile.get_var("parent_index");
NcDim* ncNamesDim = ncfile.get_dim("id_len");
NcDim* ncRecordsDim = ncfile.get_dim("recNum");
long numRecords = ncRecordsDim->size();
float values[numRecords];
float stationIds[numRecords];
int times[numRecords];
long count[1] = {numRecords};
ncvar->get(values, count);
ncTimes->get(times, count);
ncStationIds->get(stationIds, count);
// Station data
NcVar* ncNames = ncfile.get_var("station_id");
NcDim* ncLocationDim = ncfile.get_dim("station");
long numCurrLocations = ncLocationDim->size();
long namesLength = ncNamesDim->size();
char names[numCurrLocations*namesLength];
long count2[2] = {numCurrLocations, namesLength};
ncNames->get(names, count2);
ncfile.close();
// Set all values to missing
std::vector<float> vec;
vec.resize(locations.size()*offsets.size(), Global::MV);
// Read data
for(int i = 0; i < numRecords; i++) {
int id = stationIds[i];
int namesIndex = id*namesLength;
std::string name = std::string(&names[namesIndex], namesLength);
std::map<std::string,int>::const_iterator it = mLocationNames.find(name);
if(it != mLocationNames.end()) {
key.location = it->second;
key.member = 0;
int time = times[i];
int year = Global::getYear(key.date);
int month = Global::getMonth(key.date);
int day = Global::getDay(key.date);
boost::gregorian::date epochDate(1970, 1, 1);
boost::gregorian::date currDate(year, month, day);
boost::gregorian::date_period diff(epochDate, currDate);
int daysSinceEpoch = diff.length().days();
int offsetIndex = round((float) (time - 86400*daysSinceEpoch)/3600);
int secondsOffHour = (time - 86400*daysSinceEpoch) % 3600;
if(secondsOffHour < 0)
secondsOffHour = 3600 + secondsOffHour;
if(secondsOffHour > 1800) {
secondsOffHour = 3600 - secondsOffHour;
}
assert(offsetIndex >= 0);
if(secondsOffHour < mTimeTolerance && offsetIndex < 24) {
assert(key.location < locations.size());
int ind = offsetIndex*locations.size() + key.location;
assert(offsetIndex >= 0 && offsetIndex < offsets.size());
key.offset = offsets[offsetIndex];
assert(ind < (int) vec.size() && ind >= 0);
//std::cout << key.location << " " << key.offset << std::endl;
// Rda dataset uses a different missing value indicator
if(values[i] == mMV)
values[i] = Global::MV;
if((mCacheOtherOffsets || iKey.offset == key.offset) ||
(mCacheOtherLocations || iKey.location == key.location)) {
Input::addToCache(key, values[i]);
if(iKey == key) {
returnValue = values[i];
}
}
}
}
}
}
return returnValue;
}
//
// 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;
}
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;
}
int TestSuite::testVar()
{
try
{
string FILE_NAME = "tst_vars.nc";
int NDIMS = 4;
int NLAT = 6;
int NLON = 12;
// Names of things.
string LAT_NAME = "latitude";
string LON_NAME = "longitude";
int MAX_ATT_LEN = 80;
// These are used to construct some example data.
float START_LAT = 25.0;
float START_LON = -125.0;
string UNITS = "units";
string DEGREES_EAST = "degrees_east";
string DEGREES_NORTH = "degrees_north";
// For the units attributes.
string LAT_UNITS = "degrees_north";
string LON_UNITS = "degrees_east";
// Return this code to the OS in case of failure.
#define NC_ERR 2
// We will write latitude and longitude fields.
float lats[NLAT],lons[NLON];
// create some pretend data. If this wasn't an example program, we
// would have some real data to write for example, model output.
for (int lat = 0; lat < NLAT; lat++)
lats[lat] = START_LAT + 5. * lat;
for (int lon = 0; lon < NLON; lon++)
lons[lon] = START_LON + 5. * lon;
// Create the file.
NcFile test(FILE_NAME, NcFile::Replace);
// Define the dimensions. NetCDF will hand back an ncDim object for
// each.
NcDim* latDim = test.addDim(LAT_NAME, NLAT);
NcDim* lonDim = test.addDim(LON_NAME, NLON);
// Define the coordinate variables.
NcVar* latVar = test.addVar(LAT_NAME, ncFloat, latDim);
NcVar* lonVar = test.addVar(LON_NAME, ncFloat, lonDim);
// Define units attributes for coordinate vars. This attaches a
// text attribute to each of the coordinate variables, containing
// the units.
latVar->addAtt(UNITS,ncString, DEGREES_NORTH);
lonVar->addAtt(UNITS,ncString, DEGREES_EAST);
// Write the coordinate variable data to the file.
latVar->put(lats, NLAT);
lonVar->put(lons, NLON);
NcValues *latVals = latVar->getValues();
cout<<"toString returns lats: "<<latVals->toString()<<endl;
cout<<"toChar returns "<<latVals->toChar(1)<<endl;
cout<<"toShort returns "<<latVals->toShort(1)<<endl;
cout<<"toInt returns "<<latVals->toInt(1)<<endl;
cout<<"toLong returns "<<latVals->toLong(1)<<endl;
latVals->print(cout);
NcValues *lonVals = lonVar->getValues();
cout<<"toString returns lats: "<<lonVals->toString()<<endl;
lonVals->print(cout);
cout<<"no segmentation fault thus far"<<endl;
//test varaibles here
}
catch(NcException e)
{
e.what();
return 1;
}
try
{
cout<<"should test adding a variable with more than 5 dimensions here"<<endl;
// test creating a variable with more than 5 dimensions
}
catch (NcException e)
{
e.what();
return 1;
}
try //write the file with float's b/c that's all NcValues can handle at the moment
{
int NX = 6;
int NY = 12;
float dataOut[NX][NY];
// Create some pretend data. If this wasn't an example program, we
// would have some real data to write, for example, model output.
for(int i = 0; i < NX; i++)
for(int j = 0; j < NY; j++)
dataOut[i][j] = i * NY + j;
// The default behavior of the C++ API is to throw an exception i
// an error occurs. A try catch block in necessary.
// Create the file. The Replace parameter tells netCDF to overwrite
// this file, if it already exists.
string filename ="simples_xy.nc";
NcFile dataFile(filename, NcFile::Replace);
// When we create netCDF dimensions, we get back a pointer to an
// NcDim for each one.
NcDim* xDim = dataFile.addDim("x", NX);
NcDim* yDim = dataFile.addDim("y", NY);
// Define the variable. The type of the variable in this case is
// ncInt (32-bit integer).
NcVar *data = dataFile.addVar("data", ncFloat, xDim, yDim);
// Write the pretend data to the file. Although netCDF supports
// reading and writing subsets of data, in this case we write all
// the data in one operation.
data->put(&dataOut[0][0], NX, NY,0,0,0);
// The file will be automatically close when the NcFile object goes
// out of scope. This frees up any internal netCDF resources
// associated with the file, and flushes any buffers.
cout << "*** SUCCESS writing example file simples_xy.nc!" << endl;
}
catch(std::exception e)
{e.what();}
try
{
int NX = 6;
int NY = 12;
// Return this in event of a problem.
// int NC_ERR = 2;
// This is the array we will read.
float dataIn[NX][NY];
// Open the file. The ReadOnly parameter tells netCDF we want
// read-only access to the file.
NcFile dataFile("simples_xy.nc", NcFile::ReadOnly);
// Retrieve the variable named "data"
NcVar *data = dataFile.getVar("data");
//call getType on data
// Read all the values from the "data" variable into memory.
data->get(&dataIn[0][0], NX, NY);
// Check the values.
for (int i = 0; i < NX; i++)
for (int j = 0; j < NY; j++)
if (dataIn[i][j] != i * NY + j)
return 1;
NcValues* dataVar= data->getValues();
cout<<dataVar->toString()<<endl;;
dataVar->print(cout);
}
catch(NcException e)
{
e.what();
return 1;
}
cout<<"***************** Testing Variables was successful *****************"<<endl;
return 0;
}
void ReadCFTimeDataFromNcFile(
NcFile * ncfile,
const std::string & strFilename,
std::vector<Time> & vecTimes,
bool fWarnOnMissingCalendar
) {
// Empty existing Time vector
vecTimes.clear();
// Get time dimension
NcDim * dimTime = ncfile->get_dim("time");
if (dimTime == NULL) {
_EXCEPTION1("Dimension \"time\" not found in file \"%s\"",
strFilename.c_str());
}
// Get time variable
NcVar * varTime = ncfile->get_var("time");
if (varTime == NULL) {
_EXCEPTION1("Variable \"time\" not found in file \"%s\"",
strFilename.c_str());
}
if (varTime->num_dims() != 1) {
_EXCEPTION1("Variable \"time\" has more than one dimension in file \"%s\"",
strFilename.c_str());
}
if (strcmp(varTime->get_dim(0)->name(), "time") != 0) {
_EXCEPTION1("Variable \"time\" does not have dimension \"time\" in file \"%s\"",
strFilename.c_str());
}
// Calendar attribute
NcAtt * attTimeCal = varTime->get_att("calendar");
std::string strCalendar;
if (attTimeCal == NULL) {
if (fWarnOnMissingCalendar) {
Announce("WARNING: Variable \"time\" is missing \"calendar\" attribute; assuming \"standard\"");
}
strCalendar = "standard";
} else {
strCalendar = attTimeCal->as_string(0);
}
Time::CalendarType eCalendarType =
Time::CalendarTypeFromString(strCalendar);
// Units attribute
NcAtt * attTimeUnits = varTime->get_att("units");
if (attTimeUnits == NULL) {
_EXCEPTION1("Variable \"time\" is missing \"units\" attribute in file \"%s\"",
strFilename.c_str());
}
std::string strTimeUnits = attTimeUnits->as_string(0);
// Load in time data
DataVector<int> vecTimeInt;
DataVector<float> vecTimeFloat;
DataVector<double> vecTimeDouble;
DataVector<ncint64> vecTimeInt64;
if (varTime->type() == ncInt) {
vecTimeInt.Initialize(dimTime->size());
varTime->set_cur((long)0);
varTime->get(&(vecTimeInt[0]), dimTime->size());
} else if (varTime->type() == ncFloat) {
vecTimeFloat.Initialize(dimTime->size());
varTime->set_cur((long)0);
varTime->get(&(vecTimeFloat[0]), dimTime->size());
} else if (varTime->type() == ncDouble) {
vecTimeDouble.Initialize(dimTime->size());
varTime->set_cur((long)0);
varTime->get(&(vecTimeDouble[0]), dimTime->size());
} else if (varTime->type() == ncInt64) {
vecTimeInt64.Initialize(dimTime->size());
varTime->set_cur((long)0);
varTime->get(&(vecTimeInt64[0]), dimTime->size());
} else {
_EXCEPTION1("Variable \"time\" has invalid type "
"(expected \"int\", \"int64\", \"float\" or \"double\")"
" in file \"%s\"", strFilename.c_str());
}
for (int t = 0; t < dimTime->size(); t++) {
Time time(eCalendarType);
if (varTime->type() == ncInt) {
time.FromCFCompliantUnitsOffsetInt(
strTimeUnits,
vecTimeInt[t]);
} else if (varTime->type() == ncFloat) {
time.FromCFCompliantUnitsOffsetDouble(
strTimeUnits,
static_cast<double>(vecTimeFloat[t]));
} else if (varTime->type() == ncDouble) {
time.FromCFCompliantUnitsOffsetDouble(
strTimeUnits,
vecTimeDouble[t]);
} else if (varTime->type() == ncInt64) {
time.FromCFCompliantUnitsOffsetInt(
strTimeUnits,
(int)(vecTimeInt64[t]));
}
vecTimes.push_back(time);
}
}
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);
}
}
float InputNetcdf::getValueCore(const Key::Input& iKey) const {
float returnValue = Global::MV;
std::string filename = getFilename(iKey);
int size = getNumOffsets()*getNumLocations()*getNumMembers();
float* values = new float[size];
NcFile ncfile(filename.c_str());
std::string localVariable;
bool found = getLocalVariableName(iKey.variable, localVariable);
assert(found);
if(!ncfile.is_valid() || localVariable == "") {
for(int i = 0; i < size; i++) {
values[i] = Global::MV;
}
}
else {
std::stringstream ss;
ss << "InputNetcdf: Loading " << filename << " " << iKey;
Global::logger->write(ss.str(), Logger::message);
assert(localVariable != "");
NcError q(NcError::silent_nonfatal);
NcVar* ncvar = ncfile.get_var(localVariable.c_str());
if(ncvar) {
long count[3] = {getNumOffsets(),getNumLocations(),getNumMembers()};
bool status = ncvar->get(values, count);
assert(status);
}
else {
std::stringstream ss;
ss << "InputNetcdf: File " << filename << " does not contain local variable "
<< localVariable << ". Is the file corrupts?";
Global::logger->write(ss.str(), Logger::warning);
for(int i = 0; i < size; i++) {
values[i] = Global::MV;
}
}
}
ncfile.close();
std::vector<float> offsets = getOffsets();
std::vector<Member> members = getMembers();
int oC = getOffsetIndex(iKey.offset);
int oS = mCacheOtherOffsets ? 0 : oC;
int oE = mCacheOtherOffsets ? getNumOffsets()-1 : oC;
int lC = iKey.location;
int lS = mCacheOtherLocations ? 0 : lC;
int lE = mCacheOtherLocations ? getNumLocations()-1 : lC;
int iC = iKey.member;
int iS = mCacheOtherMembers ? 0 : iC;
int iE = mCacheOtherMembers ? getNumMembers()-1 : iC;
std::vector<float> vec;
vec.assign(values, values + size);
delete[] values;
Key::Input key = iKey;
if(0 && getName() == "rda336") {
std::cout << "Date: " << iKey.date << " " << iKey.variable << " " << getName() << " " << mCacheOtherLocations << std::endl;
std::cout << oC << " " << oS << " " << oE << std::endl;
std::cout << lC << " " << lS << " " << lE << std::endl;
std::cout << iC << " " << iS << " " << iE << std::endl;
}
for(int offsetIndex = oS; offsetIndex <= oE; offsetIndex++) {
key.offset = offsets[offsetIndex];
for(key.member = iS; key.member <= iE; key.member++) {
for(key.location = lS; key.location <= lE; key.location++) {
int index = offsetIndex*getNumLocations()*getNumMembers() + key.location*getNumMembers() + key.member;
assert(index < vec.size());
Input::addToCache(key, vec[index]);
assert(!std::isinf(vec[index]));
if(key == iKey) {
returnValue = vec[index];
}
}
}
}
if(std::isnan(returnValue)) {
returnValue = Global::MV;
}
return returnValue;
}