void netcdf_mpas_read_xyzcell ( string filename, int ncells, double xcell[],
double ycell[], double zcell[] )
//****************************************************************************80
//
// Purpose:
//
// NETCDF_MPAS_READ_XYZCELL reads xCell, yCell, zCell.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 29 December 2010
//
// Author:
//
// John Burkardt
//
// Reference:
//
// Russ Rew, Glenn Davis, Steve Emmerson, Harvey Davies, Ed Hartne,
// The NETCDF User's Guide,
// Unidata Program Center, March 2009.
//
// Parameters:
//
// Input, string NC_FILENAME, the name of the NETCDF file to examine.
//
// Input, int NCELLS, the number of nodes.
//
// Output, double XCELL[NCELLS], YCELL[NCELLS], ZCELL[NCELLS], the
// coordinates of the nodes.
//
{
NcVar *var_id;
//
// Open the file.
//
NcFile ncid ( filename.c_str ( ), NcFile::ReadOnly );
//
// Get the variable values.
//
var_id = ncid.get_var ( "xCell" );
(*var_id).get ( &xcell[0], ncells );
var_id = ncid.get_var ( "yCell" );
(*var_id).get ( &ycell[0], ncells );
var_id = ncid.get_var ( "zCell" );
(*var_id).get ( &zcell[0], ncells );
//
// Close the file.
//
ncid.close ( );
return;
}
void netcdf_mpas_read_xyzvertex ( string filename, int nvertices,
double xvertex[], double yvertex[], double zvertex[] )
//****************************************************************************80
//
// Purpose:
//
// NETCDF_MPAS_READ_CELLS gets the cell center coordinates.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 01 January 2011
//
// Author:
//
// John Burkardt
//
// Reference:
//
// Russ Rew, Glenn Davis, Steve Emmerson, Harvey Davies, Ed Hartne,
// The NETCDF User's Guide,
// Unidata Program Center, March 2009.
//
// Parameters:
//
// Input, string NC_FILENAME, the name of the NETCDF file to examine.
//
// Input, int NVERTICES, the number of vertices.
//
// Output, double XVERTEX[NVERTICES], YVERTEXL[NVERTICES],
// ZVERTEX[NVERTICES], the coordinates of the nodes.
//
{
NcVar *var_id;
//
// Open the file.
//
NcFile ncid ( filename.c_str ( ), NcFile::ReadOnly );
//
// Get the variable values.
//
var_id = ncid.get_var ( "xVertex" );
(*var_id).get ( &xvertex[0], nvertices );
var_id = ncid.get_var ( "yVertex" );
(*var_id).get ( &yvertex[0], nvertices );
var_id = ncid.get_var ( "zVertex" );
(*var_id).get ( &zvertex[0], nvertices );
//
// Close the file.
//
ncid.close ( );
return;
}
int netcdf_mpas_read_nvertices ( string filename )
//****************************************************************************80
//
// Purpose:
//
// NETCDF_MPAS_READ_NVERTICES gets the number of vertices.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 30 December 2010
//
// Author:
//
// John Burkardt
//
// Reference:
//
// Russ Rew, Glenn Davis, Steve Emmerson, Harvey Davies, Ed Hartne,
// The NETCDF User's Guide,
// Unidata Program Center, March 2009.
//
// Parameters:
//
// Input, string NC_FILENAME, the name of the NETCDF file to examine.
//
// Output, int NETCDF_MPAS_READ_NVERTICES, the value of NVERTICES.
//
{
int nvertices;
long int nvertices_size;
NcDim *nvertices_id;
//
// Open the file.
//
NcFile ncid ( filename.c_str ( ), NcFile::ReadOnly );
//
// Get NCELLS, which is a NETCDF dimension.
//
nvertices_id = ncid.get_dim ( "nVertices" );
nvertices_size = (*nvertices_id).size ( );
//
// Close the file.
//
ncid.close ( );
nvertices = ( int ) nvertices_size;
return nvertices;
}
void netcdf_mpas_read_verticesoncell ( string filename, int maxedges,
int ncells, int verticesoncell[] )
//****************************************************************************80
//
// Purpose:
//
// NETCDF_MPAS_READ_VERTICESONCELLS gets verticesOnCells.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 01 January 2011
//
// Author:
//
// John Burkardt
//
// Reference:
//
// Russ Rew, Glenn Davis, Steve Emmerson, Harvey Davies, Ed Hartne,
// The NETCDF User's Guide,
// Unidata Program Center, March 2009.
//
// Parameters:
//
// Input, string NC_FILENAME, the name of the NETCDF file to examine.
//
// Input, int MAXEDGES, the maximum number of edges for a cell.
//
// Input, int NCELLS, the number of cells.
//
// Output, int VERTICESONCELLS[MAXEDGES*NCELLS];
//
{
NcVar *var_id;
//
// Open the file.
//
NcFile ncid ( filename.c_str ( ), NcFile::ReadOnly );
//
// Get the variable values.
//
var_id = ncid.get_var ( "verticesOnCell" );
(*var_id).get ( &verticesoncell[0], ncells, maxedges );
//
// Close the file.
//
ncid.close ( );
return;
}
int netcdf_mpas_read_maxedges ( string filename )
//****************************************************************************80
//
// Purpose:
//
// NETCDF_MPAS_READ_MAXEDGES gets MAXEDGES.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 01 January 2011
//
// Author:
//
// John Burkardt
//
// Reference:
//
// Russ Rew, Glenn Davis, Steve Emmerson, Harvey Davies, Ed Hartne,
// The NETCDF User's Guide,
// Unidata Program Center, March 2009.
//
// Parameters:
//
// Input, string NC_FILENAME, the name of the NETCDF file to examine.
//
// Output, int NETCDF_MPAS_READ_MAXEDGES, the value of MAXEDGES.
//
{
int maxedges;
long int maxedges_size;
NcDim *maxedges_id;
//
// Open the file.
//
NcFile ncid ( filename.c_str ( ), NcFile::ReadOnly );
//
// Get MAXEDGES, which is a NETCDF dimension.
//
maxedges_id = ncid.get_dim ( "maxEdges" );
maxedges_size = (*maxedges_id).size ( );
//
// Close the file.
//
ncid.close ( );
maxedges = ( int ) maxedges_size;
return maxedges;
}
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 netcdf_mpas_read_cellsonvertex ( string filename, int nvertices,
int cellsonvertex[] )
//****************************************************************************80
//
// Purpose:
//
// NETCDF_MPAS_READ_CELLSONVERTEX gets the cellsOnVertex information.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 30 December 2010
//
// Author:
//
// John Burkardt
//
// Reference:
//
// Russ Rew, Glenn Davis, Steve Emmerson, Harvey Davies, Ed Hartne,
// The NETCDF User's Guide,
// Unidata Program Center, March 2009.
//
// Parameters:
//
// Input, string NC_FILENAME, the name of the NETCDF file to examine.
//
// Input, int NEDGES, the number of edges.
//
// Output, int CELLSONVERTEX[3*NVERTICES];
//
{
NcVar *var_id;
//
// Open the file.
//
NcFile ncid ( filename.c_str ( ), NcFile::ReadOnly );
//
// Get the variable values.
//
var_id = ncid.get_var ( "cellsOnVertex" );
(*var_id).get ( &cellsonvertex[0], nvertices, 3 );
//
// Close the file.
//
ncid.close ( );
return;
}
boost::function<void()> zd11_c::netcdf_define(NcFile &nc, std::string const &vname)
{
auto oneDim = giss::get_or_add_dim(nc, "one", 1);
auto infoVar = nc.add_var((vname + ".info").c_str(), ncDouble, oneDim);
infoVar->add_att("m", this->m);
infoVar->add_att("n", this->n);
auto neDim = nc.add_dim((vname + ".ne").c_str(), this->ne);
nc.add_var((vname + ".row").c_str(), ncInt, neDim);
nc.add_var((vname + ".col").c_str(), ncInt, neDim);
nc.add_var((vname + ".val").c_str(), ncDouble, neDim);
return boost::bind(&netcdf_write, this, &nc, vname);
}
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;
}
NCDataSet* NCDataSetBuilder::createDataSet() {
returned = true;
if (RepastProcess::instance()->rank() == 0) {
NcFile* ncfile = new NcFile(dataSet->file_.c_str(), NcFile::Replace, NULL, 0, NcFile::Offset64Bits);
NcDim* runDim = ncfile->add_dim("run", 1);
NcDim* tickDim = ncfile->add_dim("tick");
ncfile->add_var("tick", ncDouble, tickDim);
for (size_t i = 0; i < dataSet->dataSources.size(); i++) {
NCDataSource* ds = dataSet->dataSources[i];
ncfile->add_var(ds->name().c_str(), ds->ncType(), tickDim, runDim);
}
dataSet->ncfile = ncfile;
}
return dataSet;
}
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)
}
boost::function<void ()> netcdf_define(
NcFile &nc,
std::string const &vname,
blitz::Array<T,rank> const &val,
std::vector<NcDim *> const &ddims = {})
{
// Type-check for unit strides
int stride = 1;
for (int i=rank-1; i>=0; --i) {
if (val.stride(i) != stride) {
fprintf(stderr, "Unexpected stride of %d (should be %d) in dimension %d (extent=%d) of %s (rank=%d)\n", val.stride(i), stride, i, val.extent(i), vname.c_str(), rank);
fprintf(stderr, "Are you trying to write a Fortran-style array? Use f_to_c() in blitz.hpp first\n");
throw std::exception();
}
//printf("(stride=%d) *= (val.extent[%d]=%d)\n", stride, i, val.extent(i));
stride *= val.extent(i);
}
// Create the required dimensions
NcDim const *dims[rank];
for (int i=0; i<rank; ++i) {
if (i >= ddims.size()) {
char dim_name[200];
sprintf(dim_name, "%s.dim%d", vname.c_str(), i);
dims[i] = nc.add_dim(dim_name, val.extent(i));
} else {
dims[i] = ddims[i];
}
assert(dims[i] != NULL);
}
// Create the variable
NcVar *nc_var = nc.add_var(vname.c_str(), get_nc_type<T>(), rank, dims);
assert(nc_var != NULL);
// Write it out (later)
return boost::bind(&netcdf_write_blitz<T,rank>, nc_var, val);
}
static int load_nc_dim(const NcFile& ncf, const string& name, bool required = true)
{
NcDim* d = 0;
try
{
d = ncf.get_dim(name.c_str());
}
catch(char* str)
{
check(!required, string(str) + "\ndimension " + name + " not found in netcdf file");
}
int size = d ? d->size() : 0;
return size;
}
boost::function<void ()> Grid_LonLat::netcdf_define(NcFile &nc, std::string const &vname) const
{
auto parent = Grid::netcdf_define(nc, vname);
NcDim *lonbDim = nc.add_dim((vname + ".lon_boundaries.length").c_str(),
this->lonb.size());
NcVar *lonb_var = nc.add_var((vname + ".lon_boundaries").c_str(),
ncDouble, lonbDim);
NcDim *latbDim = nc.add_dim((vname + ".lat_boundaries.length").c_str(),
this->latb.size());
NcVar *latb_var = nc.add_var((vname + ".lat_boundaries").c_str(),
ncDouble, latbDim);
NcVar *info_var = nc.get_var((vname + ".info").c_str());
info_var->add_att("north_pole_cap", north_pole ? 1 : 0);
info_var->add_att("south_pole_cap", south_pole ? 1 : 0);
info_var->add_att("points_in_side", points_in_side);
info_var->add_att("nlon", nlon());
info_var->add_att("nlat", nlat());
return boost::bind(&Grid_LonLat_netcdf_write, parent, &nc, this, vname);
}
void Grid_LonLat::read_from_netcdf(NcFile &nc, std::string const &vname)
{
Grid::read_from_netcdf(nc, vname);
NcVar *info_var = nc.get_var((vname + ".info").c_str());
north_pole = (giss::get_att(info_var, "north_pole_cap")->as_int(0) != 0);
south_pole = (giss::get_att(info_var, "south_pole_cap")->as_int(0) != 0);
points_in_side = giss::get_att(info_var, "points_in_side")->as_int(0);
// _nlon = giss::get_att(info_var, "nlon")->as_int(0);
// _nlat = giss::get_att(info_var, "nlat")->as_int(0);
lonb = giss::read_double_vector(nc, vname + ".lon_boundaries");
latb = giss::read_double_vector(nc, vname + ".lat_boundaries");
}
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 CopyNcVarIfExists(
NcFile & ncIn,
NcFile & ncOut,
const std::string & strVarName,
bool fCopyAttributes,
bool fCopyData
) {
// Turn off fatal errors in NetCDF
NcError error(NcError::silent_nonfatal);
NcVar * var = ncIn.get_var(strVarName.c_str());
if (var != NULL) {
CopyNcVar(ncIn, ncOut, strVarName, fCopyAttributes, fCopyData);
}
}
void ConstantSet::netcdf_define(NcFile &nc, std::string const &vname)
{
// Create the variable to store our constants
NcVar *ncvar = giss::get_var_safe(nc, vname.c_str(), false);
if (!ncvar) {
auto oneDim = giss::get_or_add_dim(nc, "one", 1);
ncvar = nc.add_var(vname.c_str(), ncDouble, oneDim);
}
// Store the constants as attributes
for (int i=0; i<fields.size_withunit(); ++i) {
CoupledField const &field(fields.field(i));
ncvar->add_att(field.name.c_str(), vals[i]);
ncvar->add_att((field.name + "_units").c_str(), field.units.c_str());
ncvar->add_att((field.name + "_description").c_str(), field.description.c_str());
}
}
boost::function<void ()> netcdf_define(
NcFile &nc,
std::string const &vname_prefix, // vname = vname_prefix + vmeta.name
VarMetaData const &vmeta,
blitz::Array<T,rank> const &val,
std::vector<NcDim *> const &ddims = {})
{
std::string vname = vname_prefix + vmeta.get_name();
auto ret(netcdf_define(nc, vname, val, ddims));
NcVar *nc_var = nc.get_var(vname.c_str());
std::string const &description(vmeta.get_description());
if (description != "") nc_var->add_att("long_name", description.c_str());
std::string const &units(vmeta.get_units());
if (units != "") nc_var->add_att("units", units.c_str());
return ret;
}
void TrajectoryForecaster::readTime(const NcFile &data )
{
float *year = read1DimVar(data, "year");
float *month = read1DimVar(data, "month");
float *day = read1DimVar(data, "day");
float *hour = read1DimVar(data, "hour");
int n = data.get_var("year")->num_vals();
for ( int i=0; i<n; i++ )
{
time.push_back( ptime( boost::gregorian::date(year[i],month[i],day[i]), boost::posix_time::hours(hour[i])) );
}
delete [] year;
delete [] month;
delete [] day;
delete [] hour;
}
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;
}
void kernel::openKernelNetcdf () {
// Open the kernel file output from the solver.
using namespace netCDF;
using namespace netCDF::exceptions;
// Local mpi variables.
int myRank = MPI::COMM_WORLD.Get_rank ();
int worldSize = MPI::COMM_WORLD.Get_size ();
if (myRank == 0)
std::cout << "Opening kernel file: " << blu << fileName << rst << " with " << worldSize
<< " processors." << std::flush << std::endl;
try {
// Open the file.
NcFile dataFile (fileName, NcFile::read);
// Get variable.
NcVar NcKernel = dataFile.getVar ("rawKernel");
// Get array sizes.
NcDim procDim = NcKernel.getDim (0);
NcDim kernDim = NcKernel.getDim (1);
numWroteProcs = procDim.getSize ();
numGLLPoints = kernDim.getSize ();
if (myRank == 0)
std::cout << mgn << "Number of solver processers:\t " << numWroteProcs
<< "\nNumber of GLL points:\t\t " << numGLLPoints << rst << "\n" << std::endl;
// Set up the MPI read chunk array.
std::vector<size_t> start;
std::vector<size_t> count;
start.resize(2);
count.resize(2);
// Row major MPI read. Start at [myRank, 0]
start[0] = myRank;
start[1] = 0;
// Read until end of line [myrank, numGLLPoints]
count[0] = 1;
count[1] = numGLLPoints;
// Of course only read in with the number of processors used to create the file.
if (myRank < numWroteProcs) {
rawKernel = new float [numGLLPoints];
NcKernel.getVar (start, count, rawKernel);
}
// Destructor will close file.
} catch (NcException &error) {
std::cout << error.what() << std::endl;
std::cout << red << "Failure reading: " << fileName << std::endl;
std::exit (EXIT_FAILURE);
}
}
//
// 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 CCohortdriver::createSoilClimate(BgcData *bd, EnvData *ed, Vegetation_Env *ve,
string& datadir){
string file = datadir+ "calirestart.nc";
NcFile* resFile = new NcFile(file.c_str(), NcFile::Replace);
NcDim * chtD = resFile->add_dim("CHTID", 1);
NcDim * monD = resFile->add_dim("MON", 12);
NcDim * layD = resFile->add_dim("LAYER", MAX_SOI_LAY);
NcVar* drgV = resFile->add_var("DRG",ncInt, chtD);
NcVar* vegV = resFile->add_var("VEG",ncInt, chtD);
NcVar* numslV = resFile->add_var("NUMSL",ncInt, chtD);
NcVar* rsoilcV = resFile->add_var("RSOILC", ncDouble, layD);
NcVar* nsoilcV = resFile->add_var("NSOILC", ncDouble, layD);
NcVar* dzV = resFile->add_var("DZ", ncDouble, layD);
NcVar* typeV = resFile->add_var("TYPE", ncDouble, layD);
NcVar* poroV = resFile->add_var("PORO", ncDouble, layD);
NcVar* rootfracV = resFile->add_var("ROOTFRAC", ncDouble, layD);
NcVar* taV = resFile->add_var("TA",ncDouble, monD);
NcVar* growV = resFile->add_var("GROW",ncDouble, monD);
NcVar* co2V = resFile->add_var("CO2",ncDouble, monD);
NcVar* petV = resFile->add_var("PET",ncDouble, monD);
NcVar* eetV = resFile->add_var("EET",ncDouble, monD);
NcVar* parV = resFile->add_var("PAR",ncDouble, monD);
NcVar* envlaiV = resFile->add_var("ENVLAI",ncFloat, monD);
NcVar* tsV = resFile->add_var("TS", ncDouble, monD, layD);
NcVar* ch4V = resFile->add_var("CH4",ncDouble, monD, layD);
NcVar* liqV = resFile->add_var("LIQ",ncDouble, monD, layD);
NcVar* vwcV = resFile->add_var("VSM",ncDouble, monD, layD);
NcVar* swsV = resFile->add_var("SWS",ncDouble, monD, layD);
NcVar* iceV = resFile->add_var("ICE",ncDouble, monD, layD);
NcVar* yreetV = resFile->add_var("YREET",ncDouble, chtD);
NcVar* yrpetV = resFile->add_var("YRPET",ncDouble, chtD);
NcVar* yrco2V = resFile->add_var("YRCO2",ncDouble, chtD);
NcVar* prveetmxV = resFile->add_var("PRVEETMX",ncDouble, chtD);
NcVar* prvpetmxV = resFile->add_var("PRVPETMX",ncDouble, chtD);
numslV->put(&ed->m_soid.actual_num_soil, 1);
drgV->put(&ed->cd->drgtype, 1);
vegV->put(&ed->cd->vegtype, 1);
poroV->put(&ed->m_sois.por[0], MAX_SOI_LAY);
typeV->put(&ed->m_sois.type[0], MAX_SOI_LAY);
dzV->put(&ed->m_sois.dz[0], MAX_SOI_LAY);
rsoilcV->put(&bd->m_sois.reac[0], MAX_SOI_LAY);
nsoilcV->put(&bd->m_sois.nonc[0], MAX_SOI_LAY);
rootfracV->put(&ed->m_sois.rootfrac[0], MAX_SOI_LAY);
tsV->put(&ed->eq_ts[0][0], 12, MAX_SOI_LAY);
ch4V->put(&ed->eq_ch4[0][0], 12, MAX_SOI_LAY);
liqV->put(&ed->eq_liq[0][0], 12, MAX_SOI_LAY);
iceV->put(&ed->eq_ice[0][0], 12, MAX_SOI_LAY);
vwcV->put(&ed->eq_vwc[0][0], 12, MAX_SOI_LAY);
swsV->put(&ed->eq_sws[0][0], 12, MAX_SOI_LAY);
taV->put(&ed->eq_ta[0], 12);
petV->put(&ed->eq_pet[0], 12);
eetV->put(&ed->eq_eet[0], 12);
co2V->put(&ed->eq_co2[0], 12);
parV->put(&ed->eq_par[0], 12);
growV->put(&ed->eq_grow[0], 12);
envlaiV->put(&ve->envlaiall[0], 12);
yreetV->put(&ed->eq_y_eet, 1);
yrpetV->put(&ed->eq_y_pet, 1);
yrco2V->put(&ed->eq_y_co2, 1);
prveetmxV->put(&ed->eq_prveetmx);
prvpetmxV->put(&ed->eq_prvpetmx);
resFile->close();
delete resFile; //Yuan: if not, memory leaking may occur
// exit(0);
};
void 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 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);
}
}
void netcdf_mpas_report ( string filename )
//****************************************************************************80
//
// Purpose:
//
// NETCDF_MPAS_REPORT reads an MPAS NETCDF grid file and reports.
//
// Discussion:
//
// In this example, we want to extract all the information from a file
// of unknown type.
//
// Here, we are pretending we have no idea what's in the file, so we
// have to go step by step, making inquiries to NETCDF.
//
// As we go, we print out what we have discovered. We don't attempt
// to return any of the data.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 29 December 2010
//
// Author:
//
// John Burkardt
//
// Reference:
//
// Russ Rew, Glenn Davis, Steve Emmerson, Harvey Davies, Ed Hartne,
// The NETCDF User's Guide,
// Unidata Program Center, March 2009.
//
// Parameters:
//
// Input, string FILENAME, the name of the NETCDF file to examine.
//
{
NcAtt *att;
NcDim *dim;
int i;
int j;
long int len;
NcToken name;
int num_atts;
int num_dims;
int num_vars;
NcType type;
NcDim *unlimdimid;
NcVar *var;
cout << "\n";
cout << "NETCDF_MPAS_REPORT:\n";
cout << " Report the information stored in a NETCDF\n";
cout << " file. Although we wish to examine a file containing\n";
cout << " grid data generated by MPAS, we will assume we do not\n";
cout << " have any idea of what is in the file. So we just read,\n";
cout << " inquire, and print out.\n";
cout << "\n";
cout << " The name of the file is \"" << filename << "\"\n";
//
// Open the file.
//
NcFile ncid ( filename.c_str ( ), NcFile::ReadOnly );
//
// Return information about the NETCDF file.
//
num_dims = ncid.num_dims ( );
num_vars = ncid.num_vars ( );
num_atts = ncid.num_atts ( );
unlimdimid = ncid.rec_dim ( );
cout << "\n";
cout << "PRIMARY PARAMETERS:\n";
cout << "\n";
cout << " The number of dimensions NUM_DIMS = " << num_dims << "\n";
cout << " The number of variables NUM_VARS = " << num_vars << "\n";
cout << " The number of global attributes NUM_ATTS = " << num_atts << "\n";
cout << " The unlimited dimension (if any) UNLIMDIMID = \"" << (*unlimdimid).name ( ) << "\"\n";
//
// Retrieve global attributes.
// First, we must evaluate the constant "NC_GLOBAL".
//
// nc_global = netcdf.getConstant ( 'NC_GLOBAL' );
cout << "\n";
cout << "GLOBAL ATTRIBUTES:\n";
cout << " Att --------Name-------- Type Len\n";
cout << "\n";
for ( i = 0; i < num_atts; i++ )
{
att = ncid.get_att ( i );
name = (*att).name ( );
type = (*att).type ( );
len = (*att).num_vals ( );
cout << " " << setw(2) << i
<< " \"" << setw(18) << name << "\""
<< " " << setw(4) << type
<< " " << setw(4) << len << "\n";
}
//
// Determine names and extents of dimensions.
// Since each NAME is a char array, we make a cell array to hold them.
//
cout << "\n";
cout << "DIMENSIONS:\n";
cout << " Dim --------Name-------- Extent\n";
cout << "\n";
for ( i = 0; i < num_dims; i++ )
{
dim = ncid.get_dim ( i );
name = (*dim).name ( );
len = (*dim).size ( );
cout << " " << setw(2) << i
<< " \"" << setw(18) << name << "\""
<< " " << setw(6) << len << "\n";
}
//
// Get variable names, types, dimensions, number of attributes.
//
cout << "\n";
cout << "VARIABLES:\n";
cout << " Var --------Name-------- Type Natts Ndims Dims\n";
cout << "\n";
for ( i = 0; i < num_vars; i++ )
{
var = ncid.get_var ( i );
name = (*var).name ( );
type = (*var).type ( );
num_dims = (*var).num_dims ( );
num_atts = (*var).num_atts ( );
cout << " " << setw(2) << i
<< " \"" << setw(18) << name << "\""
<< " " << setw(4) << type
<< " " << setw(4) << num_atts
<< " " << setw(4) << num_dims
<< " ";
for ( j = 0; j < num_dims; j++ )
{
dim = (*var).get_dim ( j );
if ( j == 0 )
{
cout << "[";
}
cout << (*dim).name ( );
if ( j < num_dims - 1 )
{
cout <<",";
}
else
{
cout << "]";
}
}
cout << "\n";
}
//
// Close the file.
//
ncid.close ( );
return;
}
//
// 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;
}
void kernel::openCoordNetcdf () {
// Open the NetCDF coordinate file output from the solver.
using namespace netCDF;
using namespace netCDF::exceptions;
// Local mpi variables.
int myRank = MPI::COMM_WORLD.Get_rank ();
int worldSize = MPI::COMM_WORLD.Get_size ();
if (myRank == 0)
std::cout << "Opening coordinate file: " << blu << "./krn/xyzCrustMantle.nc" << rst
<< " with " << worldSize << " processors." << std::flush << std::endl;
try {
std::string coordName = "./krn/xyzCrustMantle.nc";
// Open the file.
NcFile dataFile (coordName, NcFile::read);
// Get variable.
NcVar NcRadius = dataFile.getVar ("radius");
NcVar NcTheta = dataFile.getVar ("theta");
NcVar NcPhi = dataFile.getVar ("phi");
// Get array sizes.
NcDim procDim = NcRadius.getDim (0);
NcDim coordDim = NcRadius.getDim (1);
numWroteProcs = procDim.getSize ();
numGLLPoints = coordDim.getSize ();
if (myRank == 0)
std::cout << mgn << "Number of solver processers:\t " << numWroteProcs
<< "\nNumber of GLL points:\t\t " << numGLLPoints << rst << "\n" << std::endl;
// Current error handling. Only can have as many cores as we did for the simulation.
if (worldSize > numWroteProcs) {
if (myRank == 0)
std::cout << red << "Currently, you can only use as many cores for processing as were used "
<< "in the forward run. Exiting.\n" << rst << std::flush << std::endl;
MPI::COMM_WORLD.Abort (EXIT_FAILURE);
exit (EXIT_FAILURE);
}
// Set up the MPI read chunk array.
std::vector<size_t> start;
std::vector<size_t> count;
start.resize(2);
count.resize(2);
// Row major MPI read. Start at [myRank, 0]
start[0] = myRank;
start[1] = 0;
// Read until end of line [myrank, numGLLPoints]
count[0] = 1;
count[1] = numGLLPoints;
// Preallocate cartesian arrays.
xStore = new float [numGLLPoints];
yStore = new float [numGLLPoints];
zStore = new float [numGLLPoints];
// Of course only read in with the number of processors used to create the file.
if (myRank < numWroteProcs) {
radius = new float [numGLLPoints];
theta = new float [numGLLPoints];
phi = new float [numGLLPoints];
NcRadius.getVar (start, count, radius);
NcTheta.getVar (start, count, theta);
NcPhi.getVar (start, count, phi);
}
// Save original arrays.
radiusOrig = new float [numGLLPoints];
thetaOrig = new float [numGLLPoints];
phiOrig = new float [numGLLPoints];
for (size_t i=0; i<numGLLPoints; i++) {
radiusOrig[i] = radius[i];
thetaOrig[i] = theta[i];
phiOrig[i] = phi[i];
}
// Destructor will close file.
} catch (NcException &error) {
std::cout << error.what() << std::endl;
std::cout << red << "Failure reading: " << fileName << std::endl;
std::exit (EXIT_FAILURE);
}
}
