C++ NcFile::get_var方法代码示例

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;
}

bool ReadAstro::open(const char *path)
{
    assert(!m_ncfile);
    m_ncfile = new NcFile(path, NcFile::ReadOnly);
    if (!m_ncfile->is_valid())
    {
        close();
        sendError("failed to open NetCDF file %s", path);
        return false;
    }

    if (m_ncfile->get_format() == NcFile::BadFormat)
    {
        close();
        sendError("bad NetCDF file");
        return false;
    }

    fprintf(stderr, "dims=%d, vars=%d, attrs=%d\n",
            m_ncfile->num_dims(), m_ncfile->num_vars(), m_ncfile->num_atts());

    for (int i = 0; i < m_ncfile->num_dims(); ++i)
    {
        fprintf(stderr, "%s: %ld\n",
                m_ncfile->get_dim(i)->name(),
                m_ncfile->get_dim(i)->size());
    }

    for (int i = 0; i < m_ncfile->num_vars(); ++i)
    {
        fprintf(stderr, "%s: dims=%d atts=%d vals=%ld type=%d\n",
                m_ncfile->get_var(i)->name(),
                m_ncfile->get_var(i)->num_dims(),
                m_ncfile->get_var(i)->num_atts(),
                m_ncfile->get_var(i)->num_vals(),
                m_ncfile->get_var(i)->type());
        //int dims = m_ncfile->get_var(i)->num_dims();
        NcVar *var = m_ncfile->get_var(i);
        for (int j = 0; j < var->num_dims(); ++j)
        {
            fprintf(stderr, "   %s: %ld edge=%ld\n",
                    var->get_dim(j)->name(),
                    var->get_dim(j)->size(),
                    var->edges()[j]);
        }
    }

    for (int i = 0; i < m_ncfile->num_atts(); ++i)
    {
        fprintf(stderr, "%s\n", m_ncfile->get_att(i)->name());
    }

    return true;
}

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;
}

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;
}

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;
}

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");
}

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);
	}
}

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;
}

    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 );
    }

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);
}

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;
}

//.........这里部分代码省略.........
//  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;
}

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]));
//.........这里部分代码省略.........