Next: About this document ...
Up: ESMF_refdoc
Previous: Bibliography
Contents
Subsections
49 Appendix A: Master List of Constants
This flag is documented in section 43.2.1.
49.2 ESMF_DIM_ARB
DESCRIPTION:
An integer named constant which is used to indicate that a particular dimension is arbitrarily distributed.
This flag is documented in section 37.6.1.
49.4 ESMF_ATTRECONCILE
DESCRIPTION:
Indicate whether or not to handle metadata (Attributes) in ESMF_StateReconcile().
The type of this flag is:
type(ESMF_AttReconcileFlag)
The valid values are:
- ESMF_ATTRECONCILE_ON
- Attribute reconciliation will be turned on.
- ESMF_ATTRECONCILE_OFF
- Attribute reconciliation will be turned off.
This flag is documented in section 37.6.2.
This flag is documented in section 37.6.3.
This flag is documented in section 39.2.1.
49.8 ESMF_COMPTYPE
DESCRIPTION:
Indicate the type of a Component.
The type of this flag is:
type(ESMF_CompType_Flag)
The valid values are:
- ESMF_COMPTYPE_GRID
- A ESMF_GridComp object.
- ESMF_COMPTYPE_CPL
- A ESMF_CplComp objects.
- ESMF_COMPTYPE_SCI
- A ESMF_SciComp objects.
49.9 ESMF_CONTEXT
DESCRIPTION:
Indicates the type of VM context in which a Component will be executing its
standard methods.
The type of this flag is:
type(ESMF_Context_Flag)
The valid values are:
- ESMF_CONTEXT_OWN_VM
- The component is running in its own, separate VM context. Resources
are inherited from the parent but can be arranged to fit the
component's requirements.
- ESMF_CONTEXT_PARENT_VM
- The component uses the parent's VM for resource management. Compared
to components that use their own VM context components that run in the
parent's VM context are more light-weight with respect to the overhead
of calling into their initialize, run and finalize methods.
Furthermore, VM-specific properties remain unchanged when going from
the parent component to the child component. These properties include
the MPI communicator, the number of PETs, the PET labeling,
communication attributes, threading-level.
This flag is documented in section 29.2.1.
49.11 ESMF_COPY
DESCRIPTION:
Indicates which type of copy behavior is used when copying ESMF objects.
The type of this flag is:
type(ESMF_Copy_Flag)
The valid values are:
- ESMF_COPY_ALIAS
- The destination of the copy becomes an alias of the source object.
- ESMF_COPY_REFERENCE
- All local data of the object is coped by value, and pointer valued data is referenced.
- ESMF_COPY_VALUE
- All data and pointers are copied to the destination object, nothing is referenced.
49.12 ESMF_DATACOPY
DESCRIPTION:
Indicates whether to reference a data item or make a copy of it.
The type of this flag is:
type(ESMF_DataCopy_Flag)
The valid values are:
- ESMF_DATACOPY_VALUE
- Copy the data item to another buffer.
- ESMF_DATACOPY_REFERENCE
- Reference the data item.
49.13 ESMF_DECOMP
DESCRIPTION:
Indicates how DistGrid elements are decomposed over DEs.
The type of this flag is:
type(ESMF_Decomp_Flag)
The valid values are:
- ESMF_DECOMP_BALANCED
- Decompose elements as balanced as possible across DEs. The maximum
difference in number of elements per DE is 1, with the extra elements on
the lower DEs.
- ESMF_DECOMP_CYCLIC
- Decompose elements cyclically across DEs.
- ESMF_DECOMP_DEFAULT
- Use default decomposition behavior. Currently equal to
ESMF_DECOMP_BALANCED.
- ESMF_DECOMP_RESTFIRST
- Divide elements over DEs. Assign the rest of this division to the first
DE.
- ESMF_DECOMP_RESTLAST
- Divide elements over DEs. Assign the rest of this division to the last DE.
This flag is documented in section 42.2.1.
This flag is documented in section 33.2.1.
This flag is documented in section 14.2.1.
This flag is documented in section 24.2.1.
This flag is documented in section 29.2.8.
49.19 ESMF_FILESTATUS
DESCRIPTION:
This flag is used in ESMF I/O functions. It's use is similar to the
status keyword in the Fortran open statement.
The type of this flag is:
type(ESMF_FileStatus_Flag)
The valid values are:
- ESMF_FILESTATUS_NEW
- The file must not exist, it will be created.
- ESMF_FILESTATUS_OLD
- The file must exist.
- ESMF_FILESTATUS_REPLACE
- If the file exists, all of its contents will be deleted before writing.
If the file does not exist, it will be created.
- ESMF_FILESTATUS_UNKNOWN
- The value is treated as if it were ESMF_FILESTATUS_OLD if
the corresponding file already exists. Otherwise, the value is
treated as if it were ESMF_FILESTATUS_NEW.
49.20 ESMF_GEOMTYPE
DESCRIPTION:
Different types of geometries upon which an ESMF Field or ESMF Fieldbundle may
be built.
The type of this flag is:
type(ESMF_GeomType_Flag)
The valid values are:
- ESMF_GEOMTYPE_GRID
- An ESMF_Grid, a structured grid composed of one or more logically rectangular tiles
- ESMF_GEOMTYPE_MESH
- An ESMF_Mesh, an unstructured grid
- ESMF_GEOMTYPE_XGRID
- An ESMF_XGrid, an exchange grid
- ESMF_TYPEKIND_LOCSTREAM
- An ESMF_LocStream, a disconnected series of points with associated key values
This flag is documented in section 29.2.2.
This flag is documented in section 29.2.3.
This flag is documented in section 29.2.4.
This flag is documented in section 29.2.5.
49.25 ESMF_INDEX
DESCRIPTION:
Indicates whether index is local (per DE) or global (per object).
The type of this flag is:
type(ESMF_Index_Flag)
The valid values are:
- ESMF_INDEX_DELOCAL
- Indicates that DE-local index space starts at lower bound 1 for each DE.
- ESMF_INDEX_GLOBAL
- Indicates that global indices are used. This means that DE-local index
space starts at the global lower bound for each DE.
- ESMF_INDEX_USER
- Indicates that the DE-local index bounds are explicitly set by the user.
49.26 ESMF_IOFMT
DESCRIPTION:
Indicates IO format options that are currently supported.
The type of this flag is:
type(ESMF_IOFmt_Flag)
The valid values are:
- ESMF_IOFMT_BIN
- Binary format.
- ESMF_IOFMT_NETCDF
- NETCDF and PNETCDF format.
49.27 ESMF_ITEMORDER
DESCRIPTION:
Specifies the order of items in a list.
The type of this flag is:
type(ESMF_ItemOrder_Flag)
The valid values are:
- ESMF_ITEMORDER_ABC
- The items are in alphabetical order, according to their names.
- ESMF_ITEMORDER_ADDORDER
- The items are in the order in which they were added to the container.
49.28 ESMF_KIND
DESCRIPTION:
Named constants to be used as kind-parameter in Fortran variable
declarations. For example:
integer(ESMF_KIND_I4) :: integerVariable
integer(kind=ESMF_KIND_I4) :: integerVariable
real(ESMF_KIND_R4) :: realVariable
real(kind=ESMF_KIND_R4) :: realVariable
The Fortran standard does not mandate what numeric values correspond to
actual number of bytes allocated for the various kinds. The following constants
are defined by ESMF to be correct across the supported Fortran compilers.
Note that not all compilers support every kind listed below; in particular
1 and 2 byte integers can be problematic.
The type of these named constants is:
integer
The named constants are:
- ESMF_KIND_I1
- Kind-parameter for 1 byte integer.
- ESMF_KIND_I2
- Kind-parameter for 2 byte integer.
- ESMF_KIND_I4
- Kind-parameter for 4 byte integer.
- ESMF_KIND_I8
- Kind-parameter for 8 byte integer.
- ESMF_KIND_R4
- Kind-parameter for 4 byte real.
- ESMF_KIND_R8
- Kind-parameter for 8 byte real.
This flag is documented in section 45.2.1.
This flag is documented in section 45.2.2.
This flag is documented in section 45.2.3.
This flag is documented in section 31.2.1.
49.33 ESMF_MESHLOC
DESCRIPTION:
Used to indicate a specific part of a Mesh. This is commonly used to specify the part of the Mesh to
create a Field on.
The type of this flag is:
type(ESMF_MeshLoc)
The valid values are:
- ESMF_MESHLOC_NODE
- The nodes (also known as corners or vertices) of a Mesh.
- ESMF_MESHLOC_ELEMENT
- The elements (also known as cells) of a Mesh.
49.34 ESMF_MESHOP
DESCRIPTION:
Specifies the spatial operation with two source Meshes, treating the Meshes as point sets.
The type of this flag is:
type(ESMF_MeshOp_Flag)
The valid values are:
- ESMF_MESHOP_DIFFERENCE
- Calculate the difference of the two point sets from the source Meshes.
49.35 ESMF_METHOD
DESCRIPTION:
Specify standard ESMF Component method.
The type of this flag is:
type(ESMF_Method_Flag)
The valid values are:
- ESMF_METHOD_FINALIZE
- Finalize method.
- ESMF_METHOD_INITIALIZE
- Initialize method.
- ESMF_METHOD_READRESTART
- ReadRestart method.
- ESMF_METHOD_RUN
- Run method.
- ESMF_METHOD_WRITERESTART
- WriteRestart method.
This flag is documented in section 46.2.1.
This flag is documented in section 29.2.6.
This flag is documented in section 24.2.2.
49.39 ESMF_REDUCE
DESCRIPTION:
Indicates reduce operation
The type of this flag is:
type(ESMF_Reduce_Flag)
The valid values are:
- ESMF_REDUCE_SUM
- Use arithmetic sum to add all data elements.
- ESMF_REDUCE_MIN
- Determine the minimum of all data elements.
- ESMF_REDUCE_MAX
- Determine the maximum of all data elements.
49.40 ESMF_REGION
DESCRIPTION:
Specifies various regions in the data layout of an Array or Field object.
The type of this flag is:
type(ESMF_Region_Flag)
The valid values are:
- ESMF_REGION_TOTAL
- Total allocated memory.
- ESMF_REGION_SELECT
- Region of operation-specific elements.
- ESMF_REGION_EMPTY
- The empty region contains no elements.
This flag is documented in section 24.2.3.
49.42 ESMF_ROUTESYNC
DESCRIPTION:
Switch between blocking and non-blocking execution of RouteHandle based
communication calls. Every RouteHandle based communication method contains
an optional argument routesyncflag that is of type ESMF_RouteSync_Flag.
The type of this flag is:
type(ESMF_RouteSync_Flag)
The valid values are:
- ESMF_ROUTESYNC_BLOCKING
- Execute a precomputed communication pattern in blocking mode. This
mode guarantees that when the method returns all PET-local data
transfers, both in-bound and out-bound, have finished.
- ESMF_ROUTESYNC_NBSTART
- Start executing a precomputed communication pattern in non-blocking
mode. When a method returns from being called in this mode, it
guarantees that all PET-local out-bound data has been transferred.
It is now safe for the user to overwrite out-bound data elements.
No guarantees are made for in-bound data elements at this stage. It is
unsafe to access these elements until a call in
ESMF_ROUTESYNC_NBTESTFINISH mode has been issued and has returned
with finishedflag equal to .true., or a call in
ESMF_ROUTESYNC_NBWAITFINISH mode has been issued and has returned.
- ESMF_ROUTESYNC_NBTESTFINISH
- Test whether the transfer of data of a precomputed communication
pattern, started with ESMF_ROUTESYNC_NBSTART, has completed.
Finish up as much as possible and set the finishedflag to
.true. if all data operations have completed, or
.false. if there are still outstanding transfers. Only after
a finishedflag equal to .true. has been returned is it
safe to access any of the in-bound data elements.
- ESMF_ROUTESYNC_NBWAITFINISH
- Wait (i.e. block) until the transfer of data of a precomputed
communication pattern, started with ESMF_ROUTESYNC_NBSTART, has
completed. Finish up all data operations and set the returned
finishedflag to .true.. It is safe to access any of the
in-bound data elements once the call has returned.
- ESMF_ROUTESYNC_CANCEL
- Cancel outstanding transfers for a precomputed communication pattern.
This flag is documented in section 46.2.2.
This flag is documented in section 29.2.7.
49.45 ESMF_STARTREGION
DESCRIPTION:
Specifies the start of the effective halo region of an Array or Field object.
The type of this flag is:
type(ESMF_StartRegion_Flag)
The valid values are:
- ESMF_STARTREGION_EXCLUSIVE
- Region of elements that are exclusively owned by the local DE.
- ESMF_STARTREGION_COMPUTATIONAL
- User defined region, greater or equal to the exclusive region.
This flag is documented in section 19.2.1.
This flag is documented in section 19.2.2.
49.48 ESMF_SYNC
DESCRIPTION:
Indicates method blocking behavior and PET synchronization for VM communication
methods, as well as for standard Component methods, such as Initialize(), Run()
and Finalize().
For VM communication calls the ESMF_SYNC_BLOCKING and ESMF_SYNC_NONBLOCKING
modes provide behavior that is practically identical to the blocking and
non-blocking communication calls familiar from MPI.
The details of how the blocking mode setting affects Component methods are
more complex. This is a consequence of the fact that ESMF Components can be
executed in threaded or non-threaded mode. However, in the default,
non-threaded case, where an ESMF application runs as a pure MPI or mpiuni
program, most of the complexity is removed.
See the VM item in 6.5 for an
explanation of the PET and VAS concepts used in the following
descriptions.
The type of this flag is:
type(ESMF_Sync_Flag)
The valid values are:
- ESMF_SYNC_BLOCKING
- Communication calls: The called method will block until all
(PET-)local operations are complete. After the return of a blocking
communication method it is safe to modify or use all participating
local data.
Component calls: The called method will block until all PETs of
the VM have completed the operation.
For a non-threaded, pure MPI
component the behavior is identical to calling a barrier before
returning from the method. Generally this kind of rigid
synchronization is not the desirable mode of operation for an MPI
application, but may be useful for application debugging.
In the opposite case, where all PETs of the component are running as
threads in shared memory, i.e. in a single VAS, strict synchronization
of all PETs is required to prevent race conditions.
- ESMF_SYNC_VASBLOCKING
- Communication calls: Not available for communication calls.
Component calls: The called method will block each PET until
all operations in the PET-local VAS have completed.
This mode is a combination of ESMF_SYNC_BLOCKING and
ESMF_SYNC_NONBLOCKING modes. It provides a default setting
that leads to the typically desirable behavior for pure MPI
components as well as those that share address spaces between PETs.
For a non-threaded, pure MPI component each PET returns
independent of the other PETs. This is generally the expected
behavior in the pure MPI case where calling into a component method is
practically identical to a subroutine call without extra
synchronization between the processes.
In the case where some PETs of the component are running as
threads in shared memory ESMF_SYNC_VASBLOCKING becomes identical
to ESMF_SYNC_BLOCKING within thread groups, to prevent race
conditions, while there is no synchronization between the thread
groups.
- ESMF_SYNC_NONBLOCKING
- Communication calls: The called method will not block but
returns immediately after initiating the requested operation. It is
unsafe to modify or use participating local data before all local
operations have completed. Use the ESMF_VMCommWait() or
ESMF_VMCommQueueWait() method to block the local PET until
local data access is safe again.
Component calls: The behavior of this mode is fundamentally
different for threaded and non-threaded components,
independent on whether the components use shared memory or not.
The ESMF_SYNC_NONBLOCKING mode is the most complex mode for
calling component methods and should only be used if the extra
control, described below, is absolutely necessary.
For non-threaded components (the ESMF default)
calling a component method with ESMF_SYNC_NONBLOCKING
is identical to calling it with ESMF_SYNC_VASBLOCKING. However,
different than for ESMF_SYNC_VASBLOCKING, a call to
ESMF_GridCompWait() or ESMF_CplCompWait() is
required in order to deallocate memory internally allocated for the
ESMF_SYNC_NONBLOCKING mode.
For threaded components the calling PETs
of the parent component will not be blocked and return immediately
after initiating the requested child component method. In this
scenario parent and child components will run concurrently in
identical VASs. This is the most complex mode of operation.
It is unsafe to modify or use VAS local data that
may be accessed by concurrently running components until the child
component method has completed. Use the appropriate
ESMF_GridCompWait() or ESMF_CplCompWait() method to
block the local parent PET until the child component method has
completed in the local VAS.
49.49 ESMF_TERMORDER
DESCRIPTION:
Specifies the order of source terms in a destination sum, e.g. during sparse
matrix multiplication.
The type of this flag is:
type(ESMF_TermOrder_Flag)
The valid values are:
- ESMF_TERMORDER_SRCSEQ
- The source terms are in strict ascending order according to
their source sequence index.
- ESMF_TERMORDER_SRCPET
- The source terms are first ordered according to their distribution
across the source side PETs: for each destination PET the source PET
order starts with the localPet and decrements from there, modulo
petCount, until all petCount PETs are accounted for. The term order
within each source PET is given by the source term sequence index.
- ESMF_TERMORDER_FREE
- There is no prescribed term order. The source terms may be summed in
any order that optimizes performance.
49.50 ESMF_TYPEKIND
DESCRIPTION:
Named constants used to indicate type and kind combinations supported by the
overloaded ESMF interfaces. The corresponding Fortran kind-parameter constants
are described in section 49.28.
The type of these named constants is:
type(ESMF_TypeKind_Flag)
The named constants are:
- ESMF_TYPEKIND_I1
- Indicates 1 byte integer.
- ESMF_TYPEKIND_I2
- Indicates 2 byte integer.
- ESMF_TYPEKIND_I4
- Indicates 4 byte integer.
- ESMF_TYPEKIND_I8
- Indicates 8 byte integer.
- ESMF_TYPEKIND_R4
- Indicates 4 byte real.
- ESMF_TYPEKIND_R8
- Indicates 8 byte real.
49.51 ESMF_UNMAPPEDACTION
DESCRIPTION:
Indicates what action to take with respect to unmapped destination points
and the entries of the sparse matrix that correspond to these points.
The type of this flag is:
type(ESMF_UnmappedAction_Flag)
The valid values are:
- ESMF_UNMAPPEDACTION_ERROR
- An error is issued when there exist destination points in a regridding
operation that are not mapped by corresponding source points.
- ESMF_UNMAPPEDACTION_IGNORE
- Destination points which do not have corresponding source points are
ignored and zeros are used for the entries of the sparse matrix
that is generated.
49.52 ESMF_VERSION
DESCRIPTION:
The following named constants define the precise version of ESMF in use.
- ESMF_VERSION_BETASNAPSHOT
- Constant of type logical indicating beta snapshot phase
(.true. for any version during the pre-release development phase,
.false. for any released version of the software).
- ESMF_VERSION_MAJOR
- Constant of type integer indicating the major version number
(e.g. 5 for v5.2.0r).
- ESMF_VERSION_MINOR
- Constant of type integer indicating the minor version number
(e.g. 2 for v5.2.0r).
- ESMF_VERSION_PATCHLEVEL
- Constant of type integer indicating the patch level of a specific
revision (e.g. 0 for v5.2.0r, or 1 for v5.2.0rp1).
- ESMF_VERSION_PUBLIC
- Constant of type logical indicating public vs. internal release
status (e.g. .true. for v5.2.0r, or .false. for v5.2.0).
- ESMF_VERSION_REVISION
- Constant of type integer indicating the revision number
(e.g. 0 for v5.2.0r).
- ESMF_VERSION_STRING
- Constant of type character holding the exact release version string
(e.g. "5.2.0r").
This flag is documented in section 32.2.1.
The schematic below shows the Unified Modeling Language (UML) notation
for the class diagrams presented in this Reference Manual. For
more on UML, see references such as The Unified Modeling Language
Reference Manual, Rumbaugh et al, [21].
The tables below show the possible error return codes for Fortran and
C methods.
=====================================
Fortran Symmetric Return Codes 1-500
=====================================
ESMF_SUCCESS 0
ESMF_RC_OBJ_BAD 1
ESMF_RC_OBJ_INIT 2
ESMF_RC_OBJ_CREATE 3
ESMF_RC_OBJ_COR 4
ESMF_RC_OBJ_WRONG 5
ESMF_RC_ARG_BAD 6
ESMF_RC_ARG_RANK 7
ESMF_RC_ARG_SIZE 8
ESMF_RC_ARG_VALUE 9
ESMF_RC_ARG_DUP 10
ESMF_RC_ARG_SAMETYPE 11
ESMF_RC_ARG_SAMECOMM 12
ESMF_RC_ARG_INCOMP 13
ESMF_RC_ARG_CORRUPT 14
ESMF_RC_ARG_WRONG 15
ESMF_RC_ARG_OUTOFRANGE 16
ESMF_RC_ARG_OPT 17
ESMF_RC_NOT_IMPL 18
ESMF_RC_FILE_OPEN 19
ESMF_RC_FILE_CREATE 20
ESMF_RC_FILE_READ 21
ESMF_RC_FILE_WRITE 22
ESMF_RC_FILE_UNEXPECTED 23
ESMF_RC_FILE_CLOSE 24
ESMF_RC_FILE_ACTIVE 25
ESMF_RC_PTR_NULL 26
ESMF_RC_PTR_BAD 27
ESMF_RC_PTR_NOTALLOC 28
ESMF_RC_PTR_ISALLOC 29
ESMF_RC_MEM 30
ESMF_RC_MEM_ALLOCATE 31
ESMF_RC_MEM_DEALLOCATE 32
ESMF_RC_MEMC 33
ESMF_RC_DUP_NAME 34
ESMF_RC_LONG_NAME 35
ESMF_RC_LONG_STR 36
ESMF_RC_COPY_FAIL 37
ESMF_RC_DIV_ZERO 38
ESMF_RC_CANNOT_GET 39
ESMF_RC_CANNOT_SET 40
ESMF_RC_NOT_FOUND 41
ESMF_RC_NOT_VALID 42
ESMF_RC_INTNRL_LIST 43
ESMF_RC_INTNRL_INCONS 44
ESMF_RC_INTNRL_BAD 45
ESMF_RC_SYS 46
ESMF_RC_BUSY 47
ESMF_RC_LIB 48
ESMF_RC_LIB_NOT_PRESENT 49
ESMF_RC_ATTR_UNUSED 50
ESMF_RC_OBJ_NOT_CREATED 51
ESMF_RC_OBJ_DELETED 52
ESMF_RC_NOT_SET 53
ESMF_RC_VAL_WRONG 54
ESMF_RC_VAL_ERRBOUND 55
ESMF_RC_VAL_OUTOFRANGE 56
ESMF_RC_ATTR_NOTSET 57
ESMF_RC_ATTR_WRONGTYPE 58
ESMF_RC_ATTR_ITEMSOFF 59
ESMF_RC_ATTR_LINK 60
ESMF_RC_BUFFER_SHORT 61
ESMF_RC_TIMEOUT 62
62-499 reserved for future Fortran symmetric return code definitions
=====================================
C/C++ Symmetric Return Codes 501-999
=====================================
ESMC_RC_OBJ_BAD 501
ESMC_RC_OBJ_INIT 502
ESMC_RC_OBJ_CREATE 503
ESMC_RC_OBJ_COR 504
ESMC_RC_OBJ_WRONG 505
ESMC_RC_ARG_BAD 506
ESMC_RC_ARG_RANK 507
ESMC_RC_ARG_SIZE 508
ESMC_RC_ARG_VALUE 509
ESMC_RC_ARG_DUP 510
ESMC_RC_ARG_SAMETYPE 511
ESMC_RC_ARG_SAMECOMM 512
ESMC_RC_ARG_INCOMP 513
ESMC_RC_ARG_CORRUPT 514
ESMC_RC_ARG_WRONG 515
ESMC_RC_ARG_OUTOFRANGE 516
ESMC_RC_ARG_OPT 517
ESMC_RC_NOT_IMPL 518
ESMC_RC_FILE_OPEN 519
ESMC_RC_FILE_CREATE 520
ESMC_RC_FILE_READ 521
ESMC_RC_FILE_WRITE 522
ESMC_RC_FILE_UNEXPECTED 523
ESMC_RC_FILE_CLOSE 524
ESMC_RC_FILE_ACTIVE 525
ESMC_RC_PTR_NULL 526
ESMC_RC_PTR_BAD 527
ESMC_RC_PTR_NOTALLOC 528
ESMC_RC_PTR_ISALLOC 529
ESMC_RC_MEM 530
ESMC_RC_MEM_ALLOCATE 531
ESMC_RC_MEM_DEALLOCATE 532
ESMC_RC_MEMC 533
ESMC_RC_DUP_NAME 534
ESMC_RC_LONG_NAME 535
ESMC_RC_LONG_STR 536
ESMC_RC_COPY_FAIL 537
ESMC_RC_DIV_ZERO 538
ESMC_RC_CANNOT_GET 539
ESMC_RC_CANNOT_SET 540
ESMC_RC_NOT_FOUND 541
ESMC_RC_NOT_VALID 542
ESMC_RC_INTNRL_LIST 543
ESMC_RC_INTNRL_INCONS 544
ESMC_RC_INTNRL_BAD 545
ESMC_RC_SYS 546
ESMC_RC_BUSY 547
ESMC_RC_LIB 548
ESMC_RC_LIB_NOT_PRESENT 549
ESMC_RC_ATTR_UNUSED 550
ESMC_RC_OBJ_NOT_CREATED 551
ESMC_RC_OBJ_DELETED 552
ESMC_RC_NOT_SET 553
ESMC_RC_VAL_WRONG 554
ESMC_RC_VAL_ERRBOUND 555
ESMC_RC_VAL_OUTOFRANGE 556
ESMC_RC_ATTR_NOTSET 557
ESMC_RC_ATTR_WRONGTYPE 558
ESMC_RC_ATTR_ITEMSOFF 559
ESMC_RC_ATTR_LINK 560
ESMC_RC_BUFFER_SHORT 561
ESMC_RC_TIMEOUT 562
562-999 reserved for future C/C++ symmetric return code definitions
=====================================
C/C++ Non-symmetric Return Codes 1000
=====================================
ESMC_RC_OPTARG_BAD 1000
Next: About this document ...
Up: ESMF_refdoc
Previous: Bibliography
Contents
esmf_support@list.woc.noaa.gov
