[Next] [Previous] [Top] [Contents] [Index] [netCDF Home Page] [Unidata Home Page]
NetCDF User's Guide for FORTRAN
This chapter presents the interfaces of the netCDF functions that deal with a netCDF dataset or the whole netCDF library.
A netCDF dataset that has not yet been opened can only be referred to by its dataset name. Once a netCDF dataset is opened, it is referred to by a netCDF ID, which is a small nonnegative integer returned when you create or open the dataset. A netCDF ID is much like a file descriptor in C or a logical unit number in FORTRAN. In any single program, the netCDF IDs of distinct open netCDF datasets are distinct. A single netCDF dataset may be opened multiple times and will then have multiple distinct netCDF IDs; however at most one of the open instances of a single netCDF dataset should permit writing. When an open netCDF dataset is closed, the ID is no longer associated with a netCDF dataset.
Functions that deal with the netCDF library include:
The operations supported on a netCDF dataset as a single object are:
After a summary of conventions used in describing the netCDF interfaces, the rest of this chapter presents a detailed description of the interfaces for these operations.
Each interface description for a particular netCDF function in this and later chapters contains:
In the FORTRAN function prototype and formal parameter descriptions, output parameters (in which returned values will be stored) have lower case names, to distinguish them from input parameters named in upper case.
The examples follow a simple convention for error handling, always checking the error status returned from each netCDF function call and calling a HANDLE_ERR
subroutine in case an error was detected. For an example of such a subroutine, see Section 5.2 "Get error message corresponding to error status: nc_strerror," page 30.
NF_STRERROR
The function NF_STRERROR
returns a static reference to an error message string corresponding to an integer netCDF error status or to a system error number, presumably returned by a previous call to some other netCDF function. The list of netCDF error status codes is available in the appropriate include file for each language binding.
CHARACTER*80 FUNCTION NF_STRERROR(INTEGER NCERR)
| An error status that might have been returned from a previous call to some netCDF function. |
If you provide an invalid integer error status that does not correspond to any netCDF error message or or to any system error message (as understood by the system strerror
function), nc_strerror
returns a string indicating that there is no such error status.
Here is an example of a simple error handling subroutine that uses NF_STRERROR
to print the error message corresponding to the netCDF error status returned from any netCDF function call and then exit:
INCLUDE 'netcdf.inc' ... SUBROUTINE HANDLE_ERR(STATUS) INTEGER STATUS IF (STATUS .NE. NF_NOERR) THEN PRINT *, NF_STRERROR(STATUS) STOP 'Stopped' ENDIF END
NF_INQ_LIBVERS
The function NF_INQ_LIBVERS
returns a string identifying the version of the netCDF library, and when it was built.
CHARACTER*80 FUNCTION NF_INQ_LIBVERS()
This function takes no arguments, and thus no errors are possible in its invocation.
Here is an example using NF_INQ_LIBVERS
to print the version of the netCDF library with which the program is linked:
INCLUDE 'netcdf.inc' ... PRINT *, NF_INQ_LIBVERS()
NF_CREATE
This function creates a new netCDF dataset, returning a netCDF ID that can subsequently be used to refer to the netCDF dataset in other netCDF function calls. The new netCDF dataset opened for write access and placed in define mode, ready for you to add dimensions, variables, and attributes.
A creation mode flag specifies whether to overwrite any existing dataset with the same name and whether access to the dataset is shared.
INTEGER FUNCTION NF_CREATE (CHARACTER*(*) PATH, INTEGER CMODE, INTEGER ncid)
NF_CREATE
returns the value NF_NOERR
if no errors occurred. Possible causes of errors include:
NF_NOCLOBBER
.
In this example we create a netCDF dataset named foo.nc
; we want the dataset to be created in the current directory only if a dataset with that name does not already exist:
INCLUDE 'netcdf.inc' ... INTEGER NCID, STATUS ... STATUS = NF_CREATE('foo.nc', NF_NOCLOBBER, NCID) IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS)
NF_OPEN
The function NF_OPEN
opens an existing netCDF dataset for access.
INTEGER FUNCTION NF_OPEN(CHARACTER*(*) PATH, INTEGER OMODE, INTEGER ncid)
NF_OPEN
returns the value NF_NOERR
if no errors occurred. Otherwise, the returned status indicates an error. Possible causes of errors include:
Here is an example using NF_OPEN
to open an existing netCDF dataset named foo.nc
for read-only, non-shared access:
INCLUDE 'netcdf.inc' ... INTEGER NCID, STATUS ... STATUS = NF_OPEN('foo.nc', 0, NCID) IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS)
NF_REDEF
The function NF_REDEF
puts an open netCDF dataset into define mode, so dimensions, variables, and attributes can be added or renamed and attributes can be deleted.
INTEGER FUNCTION NF_REDEF(INTEGER NCID)
NCID | NetCDF ID, from a previous call to |
NF_REDEF
returns the value NF_NOERR
if no errors occurred. Otherwise, the returned status indicates an error. Possible causes of errors include:
Here is an example using NF_REDEF
to open an existing netCDF dataset named foo.nc
and put it into define mode:
INCLUDE 'netcdf.inc' ... INTEGER NCID, STATUS ... STATUS = NF_OPEN('foo.nc', NF_WRITE, NCID) ! open dataset IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS) ... STATUS = NF_REDEF(NCID) ! put in define mode IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS)
NF_ENDDEF
The function NF_ENDDEF
takes an open netCDF dataset out of define mode. The changes made to the netCDF dataset while it was in define mode are checked and committed to disk if no problems occurred. Non-record variables may be initialized to a "fill value" as well (see Section 5.12 "Set Fill Mode for Writes: nc_set_fill," page 39). The netCDF dataset is then placed in data mode, so variable data can be read or written.
This call may involve copying data under some circumstances. See Chapter 9 "NetCDF File Structure and Performance," page 95, for a more extensive discussion.
INTEGER FUNCTION NF_ENDDEF(INTEGER NCID)
| NetCDF ID, from a previous call to |
NF_ENDDEF
returns the value NF_NOERR
if no errors occurred. Otherwise, the returned status indicates an error. Possible causes of errors include:
Here is an example using NF_ENDDEF
to finish the definitions of a new netCDF dataset named foo.nc
and put it into data mode:
INCLUDE 'netcdf.inc' ... INTEGER NCID, STATUS ... STATUS = NF_CREATE('foo.nc', NF_NOCLOBBER, NCID) IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS) ... ! create dimensions, variables, attributes STATUS = NF_ENDDEF(NCID) IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS)
NF_CLOSE
The function NF_CLOSE
closes an open netCDF dataset. If the dataset is in define mode, NF_ENDDEF
will be called before closing. (In this case, if NF_ENDDEF
returns an error, NF_ABORT
will automatically be called to restore the dataset to the consistent state before define mode was last entered.) After an open netCDF dataset is closed, its netCDF ID may be reassigned to the next netCDF dataset that is opened or created.
INTEGER FUNCTION NF_CLOSE(INTEGER NCID)
| netCDF ID, from a previous call to |
NF_CLOSE
returns the value NF_NOERR
if no errors occurred. Otherwise, the returned status indicates an error. Possible causes of errors include:
NF_ENDDEF
failed.
Here is an example using NF_CLOSE
to finish the definitions of a new netCDF dataset named foo.nc
and release its netCDF ID:
INCLUDE 'netcdf.inc' ... INTEGER NCID, STATUS ... STATUS = NF_CREATE('foo.nc', NF_NOCLOBBER, NCID) IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS) ... ! create dimensions, variables, attributes STATUS = NF_CLOSE(NCID) IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS)
NF_INQ
FamilyMembers of the NF_INQ
family of functions return information about an open netCDF dataset, given its netCDF ID. Dataset inquire functions may be called from either define mode or data mode. The first function, NF_INQ
, returns values for the number of dimensions, the number of variables, the number of global attributes, and the dimension ID of the dimension defined with unlimited length, if any. The other functions in the family each return just one of these items of information.
For FORTRAN, these functions include NF_INQ
, NF_INQ_NDIMS
, NF_INQ_NVARS
, NF_INQ_NATTS
, and NF_INQ_UNLIMDIM
.
No I/O is performed when these functions are called, since the required information is available in memory for each open netCDF dataset.
INTEGER FUNCTION NF_INQ (INTEGER NCID, INTEGER ndims, INTEGER nvars,INTEGER ngatts, INTEGER unlimdimid) INTEGER FUNCTION NF_INQ_NDIMS (INTEGER NCID, INTEGER ndims) INTEGER FUNCTION NF_INQ_NVARS (INTEGER NCID, INTEGER nvars) INTEGER FUNCTION NF_INQ_NATTS (INTEGER NCID, INTEGER ngatts) INTEGER FUNCTION NF_INQ_UNLIMDIM (INTEGER NCID, INTEGER unlimdimid)
All members of the NF_INQ family return the value NF_NOERR
if no errors occurred. Otherwise, the returned status indicates an error. Possible causes of errors include:
Here is an example using NF_INQ
to find out about a netCDF dataset named foo.nc
:
INCLUDE 'netcdf.inc' ... INTEGER STATUS, NCID, NDIMS, NVARS, NGATTS, UNLIMDIMID ... STATUS = NF_OPEN('foo.nc', NF_NOWRITE, NCID) IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS) ... STATUS = NF_INQ(NCID, NDIMS, NVARS, NGATTS, UNLIMDIMID) IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS)
NF_SYNC
The function NF_SYNC
offers a way to synchronize the disk copy of a netCDF dataset with in-memory buffers. There are two reasons you might want to synchronize after writes:
This function is backward-compatible with previous versions of the netCDF library. The intent was to allow sharing of a netCDF dataset among multiple readers and one writer, by having the writer call NF_SYNC
after writing and the readers call NF_SYNC
before each read. For a writer, this flushes buffers to disk. For a reader, it makes sure that the next read will be from disk rather than from previously cached buffers, so that the reader will see changes made by the writing process (e.g., the number of records written) without having to close and reopen the dataset. If you are only accessing a small amount of data, it can be expensive in computer resources to always synchronize to disk after every write, since you are giving up the benefits of buffering.
An easier way to accomplish sharing (and what is now recommended) is to have the writer and readers open the dataset with the NF_SHARE flag, and then it will not be necessary to call NF_SYNC
at all. However, the NF_SYNC
function still provides finer granularity than the NF_SHARE flag, if only a few netCDF accesses need to be synchronized among processes.
It is important to note that changes to the ancillary data, such as attribute values, are not propagated automatically by use of the NF_SHARE flag. Use of the NF_SYNC
function is still required for this purpose.
Sharing datasets when the writer enters define mode to change the data schema requires extra care. In previous releases, after the writer left define mode, the readers were left looking at an old copy of the dataset, since the changes were made to a new copy. The only way readers could see the changes was by closing and reopening the dataset. Now the changes are made in place, but readers have no knowledge that their internal tables are now inconsistent with the new dataset schema. If netCDF datasets are shared across redefinition, some mechanism external to the netCDF library must be provided that prevents access by readers during redefinition and causes the readers to call NF_SYNC
before any subsequent access.
When calling NF_SYNC
, the netCDF dataset must be in data mode. A netCDF dataset in define mode is synchronized to disk only when NF_ENDDEF
is called. A process that is reading a netCDF dataset that another process is writing may call NF_SYNC
to get updated with the changes made to the data by the writing process (e.g., the number of records written), without having to close and reopen the dataset.
Data is automatically synchronized to disk when a netCDF dataset is closed, or whenever you leave define mode.
INTEGER FUNCTION NF_SYNC(INTEGER NCID)
| NetCDF ID, from a previous call to |
NF_SYNC
returns the value NF_NOERR
if no errors occurred. Otherwise, the returned status indicates an error. Possible causes of errors include:
Here is an example using NF_SYNC
to synchronize the disk writes of a netCDF dataset named foo.nc
:
INCLUDE 'netcdf.inc' ... INTEGER STATUS, NCID ... STATUS = NF_OPEN('foo.nc', NF_WRITE, NCID) IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS) ... ! write data or change attributes ... STATUS = NF_SYNC(NCID) IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS)
NF_ABORT
You no longer need to call this function, since it is called automatically by NF_CLOSE
in case the dataset is in define mode and something goes wrong with committing the changes. The function NF_ABORT
just closes the netCDF dataset, if not in define mode. If the dataset is being created and is still in define mode, the dataset is deleted. If define mode was entered by a call to NF_REDEF
, the netCDF dataset is restored to its state before definition mode was entered and the dataset is closed.
INTEGER FUNCTION NF_ABORT(INTEGER NCID)
| NetCDF ID, from a previous call to |
NF_ABORT
returns the value NF_NOERR
if no errors occurred. Otherwise, the returned status indicates an error. Possible causes of errors include:
Here is an example using NF_ABORT
to back out of redefinitions of a dataset named foo.nc
:
INCLUDE 'netcdf.inc' ... INTEGER STATUS, NCID, LATID ... STATUS = NF_OPEN('foo.nc', NF_WRITE, NCID) IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS) ... STATUS = NF_REDEF(NCID) IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS) ... STATUS = NF_DEF_DIM(NCID, 'LAT', 18, LATID) IF (STATUS .NE. NF_NOERR) THEN ! dimension definition failed CALL HANDLE_ERR(STATUS) STATUS = NF_ABORT(NCID) ! abort redefinitions IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS) ENDIF ...
NF_SET_FILL
This function is intended for advanced usage, to optimize writes under some circumstances described below. The function NF_SET_FILL
sets the fill mode for a netCDF dataset open for writing and returns the current fill mode in a return parameter. The fill mode can be specified as either NF_FILL
or NF_NOFILL
. The default behavior corresponding to NF_FILL is that data is pre-filled with fill values, that is fill values are written when you create non-record variables or when you write a value beyond data that has not yet been written. This makes it possible to detect attempts to read data before it was written. See Section 7.16 "Fill Values," page 78, for more information on the use of fill values. See Section 8.1 "Attribute Conventions," page 81, for information about how to define your own fill values.
The behavior corresponding to NF_NOFILL
overrides the default behavior of prefilling data with fill values. This can be used to enhance performance, because it avoids the duplicate writes that occur when the netCDF library writes fill values that are later overwritten with data.
A value indicating which mode the netCDF dataset was already in is returned. You can use this value to temporarily change the fill mode of an open netCDF dataset and then restore it to the previous mode.
After you turn on NF_NOFILL
mode for an open netCDF dataset, you must be certain to write valid data in all the positions that will later be read. Note that nofill mode is only a transient property of a netCDF dataset open for writing: if you close and reopen the dataset, it will revert to the default behavior. You can also revert to the default behavior by calling NF_SET_FILL
again to explicitly set the fill mode to NF_NOFILL
.
There are three situations where it is advantageous to set nofill mode:
NF_ENDDEF
and then write completely all non-record variables and the initial records of all the record variables you want to initialize.
NF_ENDDEF
then write all the new variables completely.
If the netCDF dataset has an unlimited dimension and the last record was written while in nofill mode, then the dataset may be shorter than if nofill mode was not set, but this will be completely transparent if you access the data only through the netCDF interfaces.
The use of this feature may not be available (or even needed) in future releases. Programmers are cautioned against heavy reliance upon this feature.
INTEGER FUNCTION NF_SET_FILL(INTEGER NCID, INTEGER FILLMODE, INTEGER old_mode)
NF_SET_FILL
returns the value NF_NOERR
if no errors occurred. Otherwise, the returned status indicates an error. Possible causes of errors include:
NF_NOFILL
nor NF_FILL
.
Here is an example using NF_SET_FILL
to set nofill mode for subsequent writes of a netCDF dataset named foo.nc
:
INCLUDE 'netcdf.inc' ... INTEGER NCID, STATUS, OMODE ... STATUS = NF_OPEN('foo.nc', NF_WRITE, NCID) IF (STATUS .NE. NF_NOERR) CALL HANDLE_ERR(STATUS) ... ! write data with default prefilling behavior ... OMODE = NF_SET_FILL(NCID, NF_NOFILL) ... ! write data with no prefilling ...
[Next] [Previous] [Top] [Contents] [Index] [netCDF Home Page] [Unidata Home Page]