Home | Support | Components | Partners | Presentations | Projects | Publications

About ESMF Download Users Developers Management Work Plans Metrics Impacts

Releases

ESMF releases are listed below along with their matching documentation. Internal releases are shown in white cells. Internal releases are rarely patched.

Public releases are shown in orange cells. They have an "r" after the release name, e.g. 2_2_2r. Public releases that have been patched are labeled with their patch number e.g. "rp1", "rp2".



Version Date Release Notes Known Bugs
HEAD

Reference Manual built from CVS HEAD
(html) (pdf)

User's Guide built from CVS HEAD
(html) (pdf) 		Current The CVS HEAD tag represents the most recently checked in source code and does not always compile nor run. Users will generally want to download the most recent release with a specific version number below. The documentation available at left is auto-generated daily and may be missing or have formatting errors. Known bugs are not listed here. See the SourceForge bugs list.
ESMF_5_0_0

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		5/28/10
  • List of ESMF interface changes since ESMF_4_0_0rp2.
  • Tables summarizing the ESMF regridding status have been compiled. These include supported grids and capabilities in the offline and online regridding and numerical results of some specific test cases.
  • ESMF_StatePrint() has a new nestedFlag argument for printing nested States. The options argument now supports 'short' and 'long' printouts. (Default is short.)
  • ESMF_StateValidate() has a new nestedFlag argument for validating nested States.
  • ESMF_StateGet() has a new nestedFlag argument for inquiry requests, which allows returning lists of nested objects and their types.
  • The following methods were removed: ESMF_StateSetNeeded(), ESMF_StateIsNeeded(), and ESMF_StateGetNeeded().
    The reason for removal is that the semantics surrounding these routines were not well-defined, and they were rarely used. These methods may be revisited as part of an ongoing investigation into broader interoperability issues.
  • Implemented halo communication operation for Field, FieldBundle, Array and ArrayBundle classes. Variable and asymmetric halo depths are supported.
  • Added regridding support for FieldBundle objects. First order conservative regridding has been added as a modification to the existing Field regridding methods in both the offline and online and regridding. This modification is based on a finite element L2 projection method. In this initial version quantities are conserved globally. Further work is required for satisfactory local conservation.
  • Improved the algorithm in ESMF_FieldRegridStore() to fix problems with interpolation on a sphere. The change fixes incidents of destination points that are lying close to the boundary between two source elements from being mapped into the wrong element. This led to errors in the interpolation weights.
  • The offline weight generation application for structured grids has been more accurately renamed to ESMC_RegridWgtGenEx. The bilinear interpolation option, as well as a conservative option was added. For details please see the "Structured Grid to Structured Grid" subsection under the "File Based Regrid Weight Applications" section in the "Infrastructure: Fields and Grids" part of the ESMF Reference Manual.
  • Added a new offline weight generation application called ESMF_CubedSphereRegridEx. This application supports regridding between a cubed sphere and a 2D logically rectangular grid mapped to a sphere. The user may use higher-order patch recovery interpolation or bilinear interpolation between the grids. For details please see the "Cubed Sphere to Structured Grid" subsection under the "File Based Regrid Weight Applications" section in the "Infrastructure: Fields and Grids" part of the ESMF Reference Manual.
  • Support the reuse of RouteHandles for Fields and Arrays where the size of the undistributed dimensions that come before the first distributed dimension is different from the size used during the precompute.
  • RouteHandle-based Array communication calls now provide a non-blocking option. This option allows user code to overlap computation with communication.
  • Improved the implementation of ESMF_GridMatch(). Previously the method just checked to see if the Grids had identical pointers, now it checks to see if the two Grids' internal data is the same (dimensions, coordinates, items, etc.). This means that two Grids constructed independently of each other are checked more reliably.
  • Added an option to ESMF_MeshGet() to allow users to retrieve coordinates for just the locally owned Mesh nodes. These coordinates will correspond exactly with the data elements stored in a Field created on the Mesh. This is useful for setting data in the Field or performing calculations involving coordinates on the data in a Field.
  • Added the ability to validate Attributes read from an XML file by specifying a corresponding XSD file in method ESMF_AttributeRead(), via new optional argument schemaFileName. For standard ESMF-supplied Component, Field, and Grid Attribute packages validation is performed automatically, without the need to specify schemaFileName. For examples see the Attribute section of the ESMF Reference Manual.
  • XML Attribute file writing is now done with the open source third party Xerces C++ library, replacing the previous internally hard-coded fprintf() technique. For reading and/or writing XML Attribute files, ESMF must be built against the Xerces library, which requires the setting of additional ESMF environment variables. See the "Third Party Libraries" section in the ESMF User's Guide for details.
  • A new system test, ESMF_FieldRegridMeshToMesh, was added to demonstrate regridding between Fields built on unstructured Meshes.
  • FieldBundles don't currently enforce that every contained Field is built on the same Grid, although the documentation says that this should be so.
  • The Field description in the reference manual incorrectly states that the halo update operation is not supported. Field halo is available in this release.
  • ESMF_FieldRegridStore() doesn't currently work on Fields created on Meshes which contain tetrahedra.
  • ESMF_FieldRegridStore() doesn't currently work on Fields created on Grids which contain a DE of width less than 2 elements.
  • ESMF_FieldRegridStore() doesn't currently work on Fields created on Grids of arbitrary distribution.
  • ESMF_FieldRegridStore() only works on Fields created on Grids with indexflag equal to ESMF_INDEX_GLOBAL. This is not the default.
  • Grid edge connections don't work in this release and will have no effect on the actions of ESMF_FieldRegridStore().
  • Testing on a constant field has shown that the integration weights that are generated for the conservative regridding are accurate to only 9 decimal places, rather than the expected 15 decimal places. This limits the precision of the conservative regridding method.
  • The conservative regridding may generate errors when the destination grid is of higher resolution than the source grid, specifically:
    • Values of destination points will not be set when the destination cell lies completely within a single source cell.
    • There can be regions of high interpolation error where shifting grid alignment causes different numbers of source points to contribute to the destination point.
    These drawbacks are due to the fact that this conservative method does not have a constraint on local conservation.
  • The ESMF_CubedSphereRegridEx produces some suspicious interpolation weights (large, outside [0,1]). These should be further investigated to see if they are within the bounds of expected results for non-monotonic remapping methods or represent true errors.
  • ESMF_AttributeWrite() only works for ESMF standard Attribute packages.
  • Also see SourceForge bugs list.
Platform-specific bugs:
  • Discover: ESMF_ArrayRedistOpenMPSTest.F90 fails with intelmpi when run by an automatic test script, but runs correctly when executed manually.
  • SunOS test platform: the C interfaces do not work (seg fault).
  • SunOS test platform: the ESMF_AttributeSTest.F90 and ESMF_AttributeUpdateEx.F90 fail.
  • SunOS test platform: the ESMF_FieldRegridDisjointSTest.F90 system test fails.
  • SunOS test platform: the Field test harness results are ignored.
  • Windows/MinGW with intel and intelcl: the ESMF_ArrayRedistOpenMPSTest.F90, and ESMF_FieldArbGridUTest.F90 fail.
  • Windows/Cygwin g95: the ESMF_MeshUTest.F90 fails.
  • Windows/Cygwin g95: ESMF_LogErrUTest.F90 fails intermittently.
ESMF_4_0_0rp2

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		5/11/10
  • Added support for the Intel compiler suite on the Cray XT platform.
  • Added support for the PGI 10.x compiler version.
  • The same as ESMF_4_0_0rp1 with the following exceptions:
    • Negative whole numbers specified as 8-byte floating point values for *_r8 time units in ESMF_TimeSet() and ESMF_TimeIntervalSet() methods now retain their sign, remaining negative.
    • Proxy Field objects, internally created during ESMF_StateReconcile(), now return the correct dimCount.
    • Also see SourceForge bugs list.
Platform-specific bugs:
  • Windows/Cygwin g95: ESMF_MeshUTest.F90 fails with what appears to be an incompatibility between C++ exceptions and the g95 driver on Cygwin.
ESMF_4_0_0rp1

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		3/23/10
  • List of ESMF interface changes since ESMF_4_0_0r.
  • The performance of ESMF_StateReconcile() for large processor counts has been improved dramatically.
  • During ESMF_FieldRegridStore() pole elements are no longer created if the source Grid extends all the way to the pole. Previously degenerate zero-sized elements were erroneously created around the pole for this case.
  • Added ESMF_LocStreamCreate() that allows a user to create a LocStream from a background Grid or Mesh. This call creates a new LocStream that is a redistribution of an existing LocStream. The new LocStream is created so that an element with a given set of coordinates is located on the PET with the piece of background Grid (or Mesh) that contains those coordinates.
  • Added support for replicated dimensions in Field along all Grid dimensions. A gridToFieldMap argument containing all zeros in ESMF_FieldCreate() and ESMF_FieldSetCommit() indicates that no Grid dimensions are part of the Field. Instead the Field is replicated across all the DEs along all the Grid dimensions.
  • An "advice to installers" paragraph has been added to the Installation section of the User Guide. The paragraph recommends that a standard environment variable named ESMFMKFILE be set by the system to point to the "esmf.mk" file of the ESMF installation. Standardizing this aspect of the ESMF installation process promotes the design of portable ESMF application build systems.
  • The linker flags that are provided to the user through "esmf.mk" on the ORNL Cray XT systems are now portable between jaguar (XT4) and jaguarpf (XT5).
  • The "mvapich2" option was added to build environment variable ESMF_COMM. Please refer to the second table in the Supported Platforms section of the User Guide to see where it can be used.
  • A number of known bugs have been fixed, including issues with repeating sticky and non-sticky Alarms. Please see the known bugs list for more information.
  • The same as ESMF_4_0_0r with the following exceptions:
    • The problem that caused segmentation faults in ESMF_StateReconcile() has been fixed.
    • Repeating sticky Alarms whose ringInterval is less than or equal to the Clock's timeStep now ring properly.
    • Repeating sticky Alarms that are not turned off during a waiting period of a Clock run now ring properly after the waiting period is over, Alarms are cleared, and turning off of subsequent Alarms resumes.
    • Repeating non-sticky Alarms now ring properly for a Clock that goes into ESMF_MODE_REVERSE at the Clock's stopTime, while an Alarm is ringing.
    • Windows/Cygwin gfortran and g95 no longer require the setting of environment variables ESMF_F90LINKOPTS, ESMF_CXXLINKOPTS and ESMF_F90LINKLIBS.
    • The build issue with GCC 4.4.1 has been resolved.
    • The problem that caused segmentation faults on a user's Linux system with Intel compilers and OpenMPI has been identified and corrected in the ESMF library code.
  • Also see SourceForge bugs list.

    • Platform-specific bugs:
  • Windows/Cygwin g95: ESMF_LogErrUTest.F90 fails intermittently.
ESMF_3_1_0rp3

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		2/19/10 No new features.
  • The same as ESMF_3_1_0rp2 with the following exceptions:
    • Repeating sticky Alarms whose ringInterval is less than or equal to the Clock's timeStep now ring properly.
    • Repeating sticky Alarms that are not turned off during a waiting period of a Clock run now ring properly after the waiting period is over, Alarms are cleared, and turning off of subsequent Alarms resumes.
    • Repeating non-sticky Alarms now ring properly for a Clock that goes into ESMF_MODE_REVERSE at the Clock's stopTime, while an Alarm is ringing.
  • Also see SourceForge bugs list.
ESMF_4_0_0r

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		10/30/09
  • List of ESMF interface changes since ESMF_4_0_0.
  • Component methods necessary to support user-level threading were added. These methods (such as ESMF_GridCompSetMaxPEs(); see the list of interface changes for others) allow a Component to set the characteristics of its VM before it is started up. One application of these additional methods is to share the Processing Elements (PEs), provided by the Persistent Execution Threads (PETs) of the parent Component, across a lesser number of child PETs. These PEs can then be used in user-level OpenMP threading during Component method execution.
  • Implemented the underpinnings of a Component-level automatic garbage collection scheme. An initial effect is that ESMF objects that were created within a Component will be destroyed when the Component is destroyed. Additional garbage collection features will be finished and documented in future releases.
  • Corrected ESMF_StateReconcile() code to correctly handle nested States.
  • Removed the (previously undocumented) restriction that prevented States, originating from partially overlapping Components, from being reconciled with ESMF_StateReconcile().
  • The internal buffer in ESMF_StateReconcile() is now dynamically allocated. Applications with a large number of objects contained in a State should no longer run up against internal buffer size limitations.
  • Added ESMF_StateRead() and ESMF_StateWrite() methods to read and write undistributed Arrays serially from a NetCDF file. See example in the State section of the ESMF Reference Manual.
  • The Internal State implementation has been changed so that ESMF_GridCompGetInternalState() always returns the Internal State set by the last ESMF_GridCompSetInternalState() call. The previous behavior was that it would always return the Internal State set by the first ESMF_GridCompSetInternalState() call. The same is true with equivalent CplComp methods.
  • FieldBundles can now be created from Fields built on LocStreams or Meshes.
  • Fields built on LocStreams and Meshes now work with ESMF_StateReconcile() and can therefore be transferred between Components running on different sets of PETs.
  • The farray argument in ESMF_FieldGet() method has been renamed to farrayPtr to better reflect the nature of the returned parameter, and to be consistent with the ESMF_ArrayGet() method.
  • Regrid weight generation can be performed either through an offline application or through an online interface. The offline application is a separate executable which takes in two NetCDF grid files and outputs a NetCDF interpolation weight file. The online interface (ESMF_FieldRegridStore()) takes ESMF Field descriptions and generate weights. The weights can either be returned to the user through Fortran arrays, or can be applied with a parallel sparse matrix multiply in an ESMF_FieldRegrid() call.
  • The ESMF offline weight generation application supports:
    • Regridding between a pair of 2D logically rectangular Grids mapped to a sphere.
    • Multiple pole options: 1) Pole value is an average of source values around pole, 2) Pole value is an average of n-point stencil of source values, or 3) No pole.
    • Higher-order patch recovery interpolation.
    • For details please see the "File Based Regrid Weight Application" section in the "Infrastructure: Fields and Grids" part of the ESMF reference manual.
  • The ESMF online weight generation interface supports:
    • Regridding between any combination of 2D Meshes composed of triangles and quadrilaterals, and 2D Grids composed of a single logically rectangular tile with no edge connections.
    • Regridding between any combination of 3D Meshes composed of hexahedrons, and 3D Grids composed of a single logically rectangular region.
    • Regridding between a pair of 2D logically rectangular Grids mapped to a sphere.
    • One pole option: Pole value is an average of source values around pole.
    • Source and destination point masking of Grids.
    • The ability to choose what happens to unmapped destination points: either 1) return an error if any are found, or 2) ignore and don't interpolate them.
    • Two interpolation options, 1) bilinear or 2) higher order.
    For details please see the "Field Regrid" section in the "Infrastructure: Fields and Grids" part of the ESMF reference manual.
  • A more efficient tree-based search has been added to the ESMF_FieldRegridStore() method which improves its average running time by an order of magnitude.
  • A zeroflag and a checkflag have been added to the ESMF_FieldRegrid() call. The zeroflag allows the user to control how the destination Field should be initialized before regrid, and the checkflag allows the user to turn on more extensive error checking.
  • Optimized performance of ESMF_ArraySparseMatMulStore() for cases where the sparse matrix elements (i.e. factorList and factorIndexList arguments) are provided in parallel across the calling PETs.
  • Added an overloaded method for ESMF_GridCreate() to read the specification for a 2D regularly distributed rectilinear Grid from an XML file. See example in the Grid section of the ESMF Reference Manual.
  • The Grid class now contains a DistGrid per stagger location. This change allows the memory within a Field to exactly match the size of the exclusive region (the DE local portion) of the DistGrid associated with each stagger location. Previously the exclusive region of every stagger location needed to be sized to contain the exclusive region of all the stagger locations. This change affects some interfaces, such as ESMF_GridGet(), which now can return a DistGrid per stagger location.
  • Methods in the Mesh class now generate error messages through the standard ESMF LogErr system.
  • Mesh methods can now operate correctly in child Components which are running on fewer PETs than their parents.
  • The documentation for Meshes, and Fields created on Meshes, has been vastly improved, including multiple examples of Mesh creation and improved method descriptions. In addition, more extensive input checking has been added to Mesh to make its use easier.
  • Added bounds checking to the defaultvalueList argument in ESMF_AttributeGet().
  • Added a standard Attribute package to Array.
  • Added Attribute hierarchy linking to Array and ArrayBundle.
  • Time Manager interfaces have been made more robust to gracefully handle uninitialized objects and to eliminate memory leaks.
  • Two additional system tests were added to demonstrate the sparse matrix multiply operation for Fields based on LocStreams and Meshes.
  • A new system test, ESMF_ArrayRedistOpenMP, was added to demonstrate support for user-implemented OpenMP parallelism in ESMF Components.
  • Expanded the ESMF_CompFortranAndC system test to demonstrate the inter-language usage of Mesh and Field objects through States.
  • Reworked the VM documentation section in the Reference Manual to be more user oriented.
  • Removed the remaining dependency on explicit knowledge of the shape of the Fortran dope vector. This makes the library more portable across platforms, and more robust with compiler upgrades.
  • Implemented a clearer OpenMP support strategy. Two new environment variables were introduced that can be set to ON/OFF. ESMF_OPENMP, when set to ON during the library build, will compile all library sources using OpenMP compiler flags. In this case the OpenMP compiler flags automatically become part of the compiler flags exported by esmf.mk. If the ESMF library was compiled with ESMF_OPENMP set to OFF, a second environment variable, ESMF_TESTFORCEOPENMP, can be set to force the test and example codes to build with OpenMP compiler flags.
  • A new Windows option, intelcl, has been added. This allows building ESMF with the Intel Fortran compiler and the Microsoft cl (Visual C++) compiler, using the MinGW toolchain.
C interfaces:
  • Added to the C interface the ability to add and retrieve Field objects from a State.
  • Added C interfaces for the Field class. These enable a Field to be created on a Mesh, and allow the Mesh to be retrieved.
  • Segmentation faults have been reported for ESMF_StateReconcile().
  • ESMF_FieldRegridStore() doesn't currently work on Fields created on Meshes which contain tetrahedra.
  • ESMF_FieldRegridStore() doesn't currently work on Fields created on Grids which contain a DE of width less than 2 elements.
  • ESMF_FieldRegridStore() doesn't currently work on Fields created on Grids of arbitrary distribution.
  • ESMF_FieldRegridStore() only works on Fields created on Grids with indexflag equal to ESMF_INDEX_GLOBAL. This is not the default.
  • Grid edge connections don't work in this release and will have no effect on the actions of ESMF_FieldRegridStore().
  • FieldBundles don't currently enforce that every contained Field is built on the same Grid, although the documentation says that this should be so.
  • Proxy Field objects, internally created during ESMF_StateReconcile(), return the wrong dimCount.
  • Repeating sticky Alarms whose ringInterval is less than or equal to the Clock's timeStep do not ring properly.
  • Repeating sticky Alarms that are not turned off during a waiting period of a Clock run do not ring properly after the waiting period is over, Alarms are cleared, or turning off of subsequent Alarms resumes.
  • Repeating non-sticky Alarms do not ring properly for a Clock that goes into ESMF_MODE_REVERSE at the Clock's stopTime, while an Alarm is ringing.
  • Negative whole numbers specified as 8-byte floating point values for *_r8 time units in ESMF_TimeSet() and ESMF_TimeIntervalSet() methods incorrectly lose their sign, becoming positive.
  • ESMF_AttributeWrite() only works for ESMF standard Attribute packages.
  • Also see SourceForge bugs list.
Platform-specific bugs:
  • IBM Bluefire: all the ArrayHarness unit tests fail with ESMF_ABI=32.
  • Discover: ESMF_ArrayRedistOpenMPSTest.F90 fails with intelmpi when run by an automatic test script, but runs correctly when executed manually.
  • Linux ia32 test platform: ESMF_ConfigOverviewEx.F90 and ESMF_ConfigUTest.F90 fail with PGI.
  • Linux ia32 test platform: ESMF_MeshUTest.F90 fails with PGIGCC configuration.
  • Linux x86_64 test platform: Fails 15 system tests with ESMF_ABI=x86_64_medium.
  • SunOS test platform: the C interfaces do not work (seg fault).
  • SunOS test platform: the ESMF_AttributeSTest.F90 and ESMF_AttributeUpdateEx.F90 fail.
  • SunOS test platform: the ESMF_FieldRegridDisjointSTest.F90 system test fails.
  • Windows/MinGW test platform: the ESMF_ArrayRedistOpenMPSTest.F90 and ESMF_FieldArbGridUTest.F90 fail, using the intel configuration.
  • Windows/MinGW test platform: the ESMF_ArrayRedistOpenMPSTest.F90, ESMF_FieldArbGridUTest.F90, and ESMF_FieldCreateGetUTest.F90 fail, using the intelcl configuration.
  • Windows/Cygwin gfortran: the following environment variables may need to be set on some systems in order to properly link applications:
    • export ESMF_F90LINKOPTS=-Wl,--enable-auto-import
    • export ESMF_CXXLINKOPTS=-Wl,--enable-auto-import
  • Windows/Cygwin g95: the ESMF_MeshUTest.F90 fails.
  • Windows/Cygwin g95: the following environment variables may need to be set on some systems in order to properly link applications:
    • export ESMF_F90LINKLIBS=-lgcc_s
    • export ESMF_F90LINKOPTS=-Wl,--enable-auto-import
    • export ESMF_CXXLINKOPTS=-Wl,--enable-auto-import
  • The ESMF build has been reported failing for GCC 4.4.1.
  • Segmentation faults have been reported for some of the bundled test codes on a user's Linux system with Intel compilers and OpenMPI.
ESMF_4_0_0

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		5/15/09
  • List of ESMF interface changes since ESMF_3_1_1.
  • Added public C interfaces for select methods of the Mesh class. The prefix for these methods is ESMC. We do not yet have a Reference Manual that describes these interfaces.
  • Modifications were made to selected GridComp and CplComp methods that enable use of keyword syntax for procedure arguments. This was not permitted before because they did not have explicit interfaces. Using keyword syntax ensures that the compiler will check argument types. We strongly recommend that users take advantage of this feature. All of the ESMF calls that take dummy procedure arguments, or call into previously registered user procedures, now provide explicit interfaces: ESMF_GridCompSetVM(), ESMF_GridCompSetServices(), ESMF_GridCompSetEntryPoint(), ESMF_GridCompInitialize(), ESMF_GridCompRun(), ESMF_GridCompFinalize(), ESMF_GridCompReadRestart(), ESMF_GridCompWriteRestart(), ESMF_CplCompSetVM(), ESMF_CplCompSetServices(), ESMF_CplCompSetEntryPoint(), ESMF_CplCompInitialize(), ESMF_CplCompRun(), ESMF_CplCompFinalize(), ESMF_CplCompReadRestart(), ESMF_CplCompWriteRestart().
  • Those methods that call into a user supplied routine provide two separate (optional) return codes - the standard "rc" return code for the ESMF library, and the "userRc" return code set by the user routine. If keyword syntax is not used, the two return codes can get confused, with dire results. Specifically, using the old interface argument order, without keyword syntax, would lead to incorrect rc association. Users are strongly encouraged to make appropriate changes to their codes. See the API changes page for details.
  • ESMF_GridCompSetServices() and ESMF_CplCompSetServices() now support runtime loading of ESMF components via shared objects. This allows users to maintain separate build systems for individual components in the same application. The newly added ESMF_ArrayRedistSharedObj system test demonstrates this feature.
  • Changed the behavior of ESMF_GridCompSetServices() and ESMF_CplCompSetServices() to support the MAPL/GEOS-5 Component hierarchy paradigm. For most user code the SetServices change is expected to be completely transparent. All previous versions of ESMF executed the specified SetServices routine in the context of the parent VM. Now, the specified public child routine is executed within the context of the child VM. This means that calls that would affect the child VM must be issued before the child SetServices routine is called. Two new interfaces, ESMF_GridCompSetVM() and ESMF_CplCompSetVM(), have been added that allow child component code to be called and executed from within the context of the parent VM. The benefit of the SetServices change is that the child SetServices routine may now contain calls that require execution from within the context of the child VM, e.g. creation of sub-components.
  • Added standard ReadRestart and WriteRestart methods to the ESMF_GridComp and ESMF_CplComp interfaces.
  • The ESMF_GridCompGet() and ESMF_CplCompGet() interfaces now offer access to the current method (for example, initialize, run, ...) and current phase of a Component.
  • Added "attachable methods" to ESMF States. User supplied methods can be attached, executed and removed. Currently attached user methods are ignored during ESMF_StateReconcile(), and attached methods cannot be copied or moved between States. For details see the new "Attachable Methods" section in the "Infrastructure: Utilities" part of the ESMF Reference Manual.
  • The InternalState documentation in the Reference Manual has been reworked to be more applicable to real world situations.
  • Added support in ESMF_FieldCreate() methods for Fields on arbitrarily distributed Grids. ESMF_FieldRegrid() does not yet work for arbitrarily distributed Grids. Overall, communications using Fields on arbitrarily distributed Grids have not been well tested.
  • The ESMF_FieldRegridStore() call now supports source and destination masking. The user can use this masking to tell the regrid to ignore source and/or destination points.
  • The ESMF_FieldRegridStore() call now has an unmappedDstAction flag. This allows the user to choose if they want unmapped destination points to cause an error or to be ignored.
  • A number of bug fixes and tweaks have improved the accuracy and stability of ESMF_FieldRegridStore(). This is in particular true of the higher-order interpolation weight generation.
  • Added a new public method ESMF_FieldGetBounds() to allow a user to query localDe specific data bounds.
  • Grids now have the capability to store other types of data besides coordinates. This data is referred to as Grid items. A set of new interfaces which mirror the ESMF_GridCoord interfaces has been added to Grid to support this functionality. The Grid currently supports four items and a set of new flags (ESMF_GRIDITEM_MASK, ESMF_GRIDITEM_AREA, ESMF_GRIDITEM_AREAM, ESMF_GRIDITEM_FRAC) has been added to be used in the interface to indicate the item being accessed. The ESMF_GRIDITEM_MASK item is used to store mask information for use by ESMF_FieldRegridStore().
  • Added support to create arbitrarily distributed Grids using ESMF_GridCreateShapeTile(), ESMF_GridCreate(), and ESMF_GridSetCommitShapeTile(). Other Grid interfaces have been modified as needed. Grid items do not work for arbitrarily distributed Grids.
  • Changed ESMF_GridGet() interface to get the information defined for the arbitrarily distributed Grid, including arbDim (the dimension in the DistGrid that represents the arbitrarily distributed dimension(s)), localCount (the number of PET-local arbitrarily distributed index locations), and localIndices (a list of PET-local arbitrarily distributed index locations). The names of these arguments are likely to change in future releases.
  • Added ability to read Attributes from an XML file via new method ESMF_AttributeRead(), which then attaches the Attributes to a Component, Field, or Grid.
  • XML Attribute file reading is done with the open source third party Xerces C++ library. ESMF must be built against the Xerces library, which requires the setting of additional ESMF environment variables. See the "Third Party Libraries" section in the ESMF User's Guide for details.
  • Implemented ability to specify time units as 8-byte floating point values in Time Manager methods.
  • Implemented ESMF standard Attribute packages for Components, State, Field, and Grid.
  • Added Attributes to ArrayBundle and DistGrid.
  • Allow Field Attribute hierarchy to connect to Grid Attribute hierarchy.
  • Allow ESMF_AttributeWrite() to be called from Components, State, FieldBundle, and Field.
  • Allow ESMF_AttributeCopy() to locally copy Attribute values between Components.
  • Added ESMF_AttributeUpdate() routine to build consistent Attribute structure and values for objects defined across a VM. One use of this feature is to use it in conjunction with ESMF_AttributeCopy() during the CplComp run method in order to transfer Attributes between GridComps defined on mutually exclusive sets of PETs.
  • Overloaded ESMF_AttributeRemove() to remove entire Attribute packages, Attributes in an Attribute package, or just single Attributes.
  • Added the ability to nest Attribute packages inside of each other.
  • ESMF_StateReconcile() now has a flag to allow optional Attribute reconciliation. The default is currently that Attribute reconciliation is off, due to concerns about performance and robustness.
  • Added a set of overloaded ESMF_AttributeLinkRemove() interfaces. These detach an object's Attribute hierarchy from that of another object.
  • Modified the ESMF_Attribute system test to use ESMF_AttributeUpdate(), ESMF_AttributeCopy(), and ESMF_StateReconcile() on both States and Components where appropriate.
  • The range of Fortran unit numbers used within ESMF can be overridden via the ESMF_Initialize() call by using the new IOUnitLower and IOUnitUpper optional arguments. A new ESMF_IOUnitGet() method to find an unused unit number within the ESMF unit number range is provided as a service to application developers.
  • ESMF_IOUnitFlush() is provided as a common method to flush Fortran unit numbers. This is intended for use as a service to application developers.
  • Added ESMF_ConcurrentEnsemble system test demonstrating an ensemble in which different ensemble members, which are distinctly different components, run concurrently on distinct sets of PETs.
  • Added ESMF_InternalStateEnsemble system test demonstrating how different ensemble members representing the same Component can be written using a single Component object which indexes different elements of an ESMF internal State.
  • Activated TestHarness for Array and Field testing.
  • Added support for Windows MinGW/MSYS, using the Intel Fortran and C++ compiler and Microsoft MPI. This was developed and tested under Windows Compute Cluster Server (CCS) 2003.
  • Standardized 3rd party library support (NETCDF, PNETCDF, LAPACK, XERCES).
  • An offline file-to-file regridding application has been developed as part of ESMF. This application takes two netcdf grid files and outputs interpolation weights generated using ESMF's higher-order interpolation. This application supports a number of options for handling the pole: no pole, treating the pole as the average of the values surrounding the pole, and an n-point stencil average of the points surrounding the pole. The format of the files makes this application a suitable replacement for SCRIP. For details see the new "File Based Regrid Weight Application" section in the "Infrastructure: Fields and Grids" part of the ESMF Reference Manual.
  • Furthermore, all the features listed in the release notes for ESMF_3_1_0rp2 apply to this release.
  • The ESMF_StateReconcile() call, generally used by couplers dealing with Components running on exclusive petLists, has an internal size limit (which will be addressed in a subsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 20, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile()
  • The ESMF_StateReconcile() call fails for nested States.
  • ESMF_LOG_SINGLE is known to be broken. The symptoms are platform dependent and may appear non-deterministic.
  • Fields built on LocStreams and Meshes will not work with ESMF_StateReconcile() and therefore cannot be transfered between Components running concurrently.
  • ESMF_FieldRegrid() is only implemented for Fields created on Grids with indexflag equal to ESMF_INDEX_GLOBAL. This is not the default.
  • Proxy Field objects, internally created during ESMF_StateReconcile(), return the wrong dimCount.
  • Grid connections don't work in this release and will have no effect on the actions of ESMF_FieldRegridStore().
  • Repeating sticky Alarms whose ringInterval is less than or equal to the Clock's timeStep do not ring properly.
  • Repeating sticky Alarms that are not turned off during a waiting period of a Clock run do not ring properly after the waiting period is over, Alarms are cleared, or turning off of subsequent Alarms resumes.
  • Repeating non-sticky Alarms do not ring properly for a Clock that goes into ESMF_MODE_REVERSE at the Clock's stopTime, while an Alarm is ringing.
  • Negative whole numbers specified as 8-byte floating point values for *_r8 time units in ESMF_TimeSet() and ESMF_TimeIntervalSet( ) methods incorrectly lose their sign, becoming positive.
  • Array and ArrayBundle Attribute hierarchies are not implemented yet.
  • ESMF_AttributeWrite() only works for ESMF standard Attribute packages.
  • In the Reference Manual, "Figure 29: The structure of the Attribute class" shows an attrCount variable which is no longer present, and does not show two vectors of Attribute pointers called packList and linkList.
  • In the API description of ESMF_AttributeLink() and ESMF_AttributeLinkRemove(), in the ESMF Reference Manual, the argument keyword should be "comp1" instead of "comp".
  • Also see SourceForge bugs list.
Platform-specific bugs:
  • The Mesh and ESMF_FieldRegrid() code is unstable when compiled with PGI.
  • ESMF_DistGridCreateGetUTest.F90 fails on IBM Lightning with PGI.
  • ESMF_ClockUTest.F90 fails on IBM/AIX in ESMF_BOPT=O mode.
  • ESMF_ClockUTest.F90 fails on Linux with NAG.
  • All the ArrayHarness unit tests fail on IBM Bluefire with ESMF_ABI=32 and ESMF_BOPT=g.
  • ESMC_ConfigUTest.C fails on IBM Bluefire with ESMF_ABI=64 and ESMF_BOPT=O.
  • ESMF_GridCoordUTest.F90 fails on Darwin with Absoft and with ESMF_BOPT=O.
  • The Attribute unit tests fail with Lahey and ESMF_BOPT=O.
  • ESMF_ConfigOverviewEx.F90 and ESMF_ConfigUTest.F90 fail on ia32 with PGI.
  • Examples ESMF_LogErrEx.F90, ESMF_AttReadGridCompEx.F90, ESMF_AttReadGridEx.F90, and ESMF_AttributePackageEx.F90 fail on Linux with the g95 v0.5 compiler.
  • The C unit tests and examples fail to link on wJet with the Intel compiler.
ESMF_3_1_0rp2

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		2/06/09
  • List of ESMF interface changes since ESMF_3_1_0rp1.
  • Added support for replicated dimensions in Field. A "0" entry in the gridToFieldMap argument in ESMF_FieldCreate() and ESMF_FieldSetCommit() indicates that a Grid dimension is not part of the Field. Instead the Field is replicated across all DEs along the corresponding Grid dimension.
  • Overloaded ESMF_FieldCreate() to accept a Fortran array pointer and preserve its properties (such as bounds and ability to deallocate).
  • Overloaded ESMF_FieldSetCommit() to accept a Fortran array pointer and preserve its properties (such as bounds and ability to deallocate).
  • The Grid now supports an ESMF_INDEX_USER option for the indexflag. This allows the user to explicitly set the lower bound of their local index space. This is necessary when creating a Field from a Fortran array pointer with non-standard indexing.
  • Overloaded ESMF_ArrayCreate() to accept a Fortran array pointer and preserve its properties (such as bounds and ability to deallocate).
  • Optimized ESMF_ArraySMM() and ESMF_ArrayBundleSMM() runtime performance, scalability and memory usage.
  • Added support for optimized communications for Arrays with different distributions, dimensions and sizes in the same ArrayBundle.
  • Added support for DEs with zero elements in DistGrid, Array and Field.
  • Made localDe argument optional in ESMF_ArrayGet() and ESMF_FieldGet() methods where not prohibited by overloading restrictions.
  • Alarms set to ring at timeStep 0, upon ESMF_AlarmCreate(), now ring properly.
  • Alarms now ring properly for a Clock in ESMF_MODE_REVERSE.
  • Alarms now ring properly for a Clock using a negative timeStep.
  • Added default pointer size override feature to build system utilizing new environment variables ESMF_F90_PTR_BASE_SIZE and ESMF_F90_PTR_PLUS_RANK.
  • The same as ESMF_3_1_0rp1 with the following exceptions:
    • The failure of ESMF_VMSendVMRecvUTest.F90 on IBM BlueGene/L in uni-PET mode has been fixed.
    • On the SunOS Sparc set ESMF_OPTLEVEL=2, otherwise the ESMF_DELayoutWorkQueueUTest.F90 unit test hangs running with ESMF_BOPT=O.
    • The ESMC_Component examples fail on the PC Xeon(64) Cluster with the Intel 9.1 compiler and ESMF_COMM=mpich2.
  • Also see SourceForge bugs list.
ESMF_3_1_1

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		9/11/08
  • List of ESMF interface changes since ESMF_3_1_0rp1.
  • Added public C interfaces for select methods of the following classes:
    • GridComp, CplComp
    • State
    • Clock, TimeInterval, Time, Calendar
    • Config
    • Array
    • ArraySpec
    • DistGrid
    • VM
      • The prefix for these methods is ESMC. We do not yet have a Reference Manual that describes these interfaces.
  • Restored most Field and FieldBundle communication methods except the halo update methods.
  • Added a method to perform a bilinear or higher order regridding between two Fields constructed on Grids. The Fields must be based on Grids with indexflag equal to ESMF_INDEX_GLOBAL (not the default) and must have data at cell centers (the default). This method will not work for Fields built on LocStreams or Meshes. Interpolation weights are computed in parallel.
  • Added a LocStream (Location Stream) class to represent and manipulate observational data streams. Fields can be created using a LocStream instead of a Grid.
  • Added ability to represent an unstructured Mesh in ESMF. Fields can be created using a Mesh instead of a Grid.
  • The DistGrid interface changes in this release reflect modifications that are necessary to support factorized sequence indices in the future. This feature is required for the ongoing arbitrary Grid development and is not fully supported yet.
  • Added Attributes to the CplComp and GridComp classes.
  • Added the ability to build Attribute hierarchies.
  • Added Attribute packages to CplComp, GridComp, and Field. Either standard or custom Attribute packages can be created.
  • Added a method to locally copy Attributes between States called ESMF_AttributeCopy().
  • Overloaded ESMF_AttributeGet() and ESMF_AttributeSet() to allow the manipulation of Attributes in Attribute packages.
  • Added an optional default value to ESMF_AttributeGet().
  • Added an interface to write out an Attribute hierarchy in either tab delimited or XML format called ESMF_AttributeWrite().
  • Added character lists as an option for Attribute type.
  • Standardized the use of count and itemCount in Attribute calls and made them optional in most cases.
  • Added support for the Modified Julian Day calendar, ESMF_CAL_MODJULIANDAY.
  • Alarms now ring properly for a clock in ESMF_MODE_REVERSE.
  • Argument lists for Fortran-callable entry points which contain logical data have been regularized to always use Fortran LOGICAL. Previously, some routines used the internal ESMF_Logical derived type.
  • Parallel build of the ESMF library supported via GNU make -j option.
  • Added ESMF_CompFortranAndC system test that tests and demonstrates passing of State objects between Fortran and C components.
  • Added ESMF_Attribute system test demonstrating Attribute packages and hierarchies.
  • Added ESMF_FieldBundleSMM system test demonstrating the sparse matrix multiply using FieldBundles.
  • Added ESMF_ArrayRedist3D system test demonstrating a three dimensional redistribution operation for Arrays.
  • Added ESMF_SeqEnsemEx system test demonstrating an ensemble in which different ensemble members, which are distinctly different components, run on the same set of PETs.
  • The same as ESMF_3_1_0rp1 with the following exception:
    • The problem with the ESMC Component interfaces on XLF and PGI compilers has been fixed.
  • For higher-order interpolation, ESMF_FieldRegrid() can give wrong answers for multiple processors. We recommend only using this on a single processor.
  • In this release the accuracy of the higher-order interpolation has been degraded by a bug. For better results we recommend using ESMF v4.0.0. or later.
  • ESMF_FieldRegrid() has problems with the pole. When using ESMF_REGRID_SCHEME_FULL3D, we recommend not using any destination points which either lie in a cell next to the pole (for both bilinear and higher-order) or two cells away from the pole (for just higher-order).
  • Fields built on LocStreams and Meshes cannot be transferred between Components running concurrently.
  • ESMF_FieldRegrid() is only implemented for Fields with data located at cell centers.
  • ESMF_FieldRegrid() is only implemented for Fields created on Grids with indexflag equal to ESMF_INDEX_GLOBAL. This is not the default.
  • The Grid connections don't work in this release and will have no effect on the actions of ESMF_FieldRegrid().
  • New Attribute methods are unreliable across a range of platforms. They should be considered an early prototype and used with caution.
  • On IBM Bluegene the ESMF_FieldRegridEx.F90 and ESMF_FieldSphereRegridEx.F90 fail with ESMF_BOPT=O.
  • A problem in the Config C interface leads to failures in the ESMC_ConfigUTest.C on the XLF compiler.
  • ESMF_AttributeWrite() does not write out the values in the header of the .xml file generated when calling with ESMF_AttWriteFlag=ESMF_ATTWRITE_XML.
  • The Use Test Cases were not updated or tested for this release.
  • The ESMF_ArrayHarness2UTest is incorrectly reported as failing when executed through any of ESMF's batch mode mpirun scripts.
  • Also see SourceForge bugs list.
ESMF_3_1_0rp1

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		7/25/08
  • List of ESMF interface changes since ESMF_3_1_0r.
  • Added Attributes to the Grid class.
  • Added Attributes to the Array class.
  • Added minIndex and maxIndex arguments to ESMF_GridGet(). These arguments apply to the first tile.
  • Added minIndexPDimPDe and maxIndexPDimPDe arguments to ESMF_DistGridGet().
  • Added ESMF_GridMatch() method to compare two Grid objects.
  • A new section in the User's Guide entitled "Setting up ESMF to run Test Suite Applications" was added that outlines how users can specify their own mpirun scripts. ESMF now consistently uses the setting of environment variable ESMF_MPIRUN to launch the bundled test suite and example applications.
  • A number of known bugs have been fixed. Please see the known bugs list.
  • The same as ESMF_3_1_0r with the following exceptions:
    • The problem with ESMF_ArrayRedist() and ESMF_ArraySMM() methods hanging in mpiuni mode has been fixed.
    • The problem with ESMF_ArrayRedist, ESMF_DirectCoupling and ESMF_RecursiveComponent system tests failing with a segmentation fault in ESMF_BOPT=O mode on x86_64 Darwin systems with Intel compilers has been fixed.
    • States containing FieldBundles can now be reconciled, so FieldBundles can be transferred between concurrently operating components.
    • Reconciliation errors for Fields created with user supplied arguments for gridToFieldMap, maxHaloWidths, and ungriddedBounds have been fixed.
    • Proxy Field objects, internally created during ESMF_StateReconcile(), are now properly destroyed during ESMF_StateDestroy().
    • The ESMF_AttributeGet() and ESMF_AttributeSet() Reference Manual entries that did not show a required "count" argument have been fixed.
  • Also see SourceForge bugs list.
ESMF_3_1_0r

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		5/21/08
  • List of ESMF interface changes since ESMF_3_1_0p1.
  • Shortened the names of State add and get methods so that they do not refer to the item being retrieved. For example, ESMF_StateGetField() is now just ESMF_StateGet().
  • Fixed problem in the InternalState implementation that rendered the returned Fortran pointer to the user defined derived type incomplete and unsuitable for memory deallocation across a wide range of platforms.
  • Implemented ArrayBundle class with limited support for sparse matrix and redist communication methods.
  • Renamed Bundle to FieldBundle.
  • Shortened ESMF_FieldBundleGetField() and ESMF_FieldBundleAddField() method names to ESMF_FieldBundleGet() and ESMF_FieldBundleAdd(), respectively.
  • State, Field, and FieldBundle Attribute methods were consolidated into a single set of Attribute methods that are overloaded for object type. For example, ESMF_AttributeGet() is overloaded to get Attributes from States, Fields, and Bundles. This reduces the number of documented calls in the interface significantly.
  • Field, Grid, and Array classes now interpret their width and bound arguments in a consistent way. The order of dimensions is defined by their index sequence in memory.
  • Restored the ESMF_FieldCreate() method that allows Field creation from an existing Grid and Array.
  • Restored the ESMF_FieldGet() that returns the native Fortran data pointer to Field data.
  • Implemented ESMF_FieldCreateEmpty(), which allocates the shell of a Field, and ESMF_FieldSetCommit(), which finishes a Field started by ESMF_FieldCreateEmpty().
  • Implemented a ESMF_FieldGet() method that provides precomputed bounds and counts from Grid and other Field creation parameters. This method helps users allocate native Fortran arrays to be used in ESMF_FieldCreate() and ESMF_FieldSetCommit() methods.
  • Switched Grid and Field localDe arguments to non-optional to conform to Array.
  • Grid undistributed dimensions are now always DistGrid dimensions distributed across 1 DE. This simplified interfaces and implementation. Field interfaces also reflect this change.
  • Grid now destroys internally created DELayouts, DistGrids, and Arrays.
  • Regular decompositions now behave more intuitively. Previously stagger edge padding could cause cells to be divided up oddly.
  • Added method to get GridStatus from a Grid.
  • Renamed ArraySparseMatMul methods ArraySMM to avoid method name size limits on some compilers.
  • Implemented more flexible zeroflag option in ESMF_ArraySMM() that supports zero out of only those destination elements that will be updated by the sparse matrix multiplication. This preserves special fill values if they exist.
  • Added ESMF_ArraySMMRelease() and ESMF_ArrayRedistRelease() interfaces for consistency.
  • Added ESMF_ConcurrentComp system test that demonstrates a very simple concurrent coupling scenario.
  • Added ESMF_ArrayBundleSparseMatMul system test.
  • Added ESMF_ArrayRedistMPMD system test to test and demonstrate ESMF's multiple executable support.
  • Added ESMF_RecursiveComponent system test to test and demonstrate the recursive use of ESMF Components.
  • Implemented FieldCreateGetUTest, FieldStressUTest, FieldBundleCrGetUTest to help diagnose/fix various memory associated issues.
  • Added petascale performance and memory optimization of Component creation.
  • Added support for SunOS/sparc.
  • Added support for new Cray XT4 compiler wrappers.
  • Added support for Darwin on x86 and x86_64 systems with Intel compilers.
  • Added support for gfortran version 4.3.
  • Added explicit interface blocks that ensure conformance to ESMF interfaces in user-written routines called by ESMF_GridCompSetServices() or ESMF_CplCompSetServices() and registered via the ESMF_GridCompSetEntryPoint() or ESMF_CplCompSetEntryPoint() methods.
  • Changed environment variable ESMF_EXHAUSTIVE to ESMF_TESTEXHAUSTIVE.
  • Added environment variable ESMF_TESTMPMD to turn on/off MPMD system tests.
  • Implemented running only single processor system tests from the run_system_test_uni target.
  • Removed netcdf_stubs and hdf_stubs.
  • Checked for and fixed memory leaks.
  • Reviewed and updated introductory and general sections of the Reference Manual.
  • Stagger location and bounds diagrams were added to the Grid documentation.
  • The ESMF_StateReconcile() call, generally used by couplers dealing with Components running on exclusive petLists, has an internal size limit (which will be addressed in a subsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 20, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile() .
  • FieldBundles contained inside States cannot be reconciled. This means that FieldBundles cannot be transferred between components running concurrently.
  • There are reconciliation errors for Fields created with user supplied arguments for gridToFieldMap, maxHaloWidths, and ungriddedBounds.
  • Proxy Field objects, internally created during ESMF_StateReconcile(), are not properly destroyed during ESMF_StateDestroy(). In applications that reconcile States across exclusive sets of PETs this will lead to a small memory leak for each contained Field object. This should not cause significant problems if ESMF_StateReconcile() is called once during initialization as recommended.
  • ESMF_ArrayRedist() and ESMF_ArraySMM() methods will hang in mpiuni mode. We expect this to be fixed in an upcomng patch release.
  • Repeating sticky Alarms whose ringInterval is less than or equal to the Clock's timeStep do not ring properly.
  • Repeating sticky Alarms that are not turned off during a waiting period of a Clock run do not ring properly after the waiting period is over, Alarms are cleared, or turning off of subsequent Alarms resumes.
  • Repeating non-sticky Alarms do not ring properly for a Clock that goes into ESMF_MODE_REVERSE at the Clock's stopTime, while an Alarm is ringing.
  • The documentation for ESMF_AttributeGet() and ESMF_AttributeSet() calls for multi-valued list Attributes does not show a required integer input "count" argument after the "name" argument. This has been corrected in the Reference Manual for this release shown at left. However a user who builds the documentation themselves will still see this error.
  • ESMF_LOG_SINGLE is known to be broken. The symptoms are platform dependent and may appear non-deterministic.
  • On Cray X1 the ESMF_DistDir system test fails.
  • On Cray X1 the ESMF_String unit test fails.
  • On IBM BlueGene/L ESMF_VMSendVMRecvUTest.F90 fails in uni-PET mode.
  • On x86_64 Darwin systems with Intel compilers the ESMF_ArrayRedist, ESMF_DirectCoupling and ESMF_RecursiveComponent system tests fail with segmentation fault in ESMF_BOPT=O mode.
  • ESMC_Component examples fail with the XLF and PGI compilers as well as for the Linux/absoftintel combination.
  • All NAG compiler combinations we tested (on Linux as well as on Darwin) show random run-time failures when ESMF is compiled in optimized mode and also when user code that links with ESMF is compiled in optimized mode. Consequently ESMF sets ESMF_OPTLEVEL to 0 (zero) by default when compiling ESMF with NAG and we advise NAG users to not use optimization on user code that links against the ESMF library.
  • Last time we were able to test with PGI 6.2.5 on Cray XT3/4 it failed to compile ESMF with an internal compiler error. The same version of PGI works fine on non-Cray machines. We were unable to test with this compiler version on Cray XT3/4 to determine the status of this issue with 3.1.0r.
  • Also see SourceForge bugs list.
ESMF_3_1_0p1

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		2/27/08
  • List of ESMF interface changes since ESMF_3_1_0.
  • Added garbage collection of proxy objects to ESMF_StateDestroy(). This fixes several memory leaks in system tests.
  • Re-enabled the ESMF_FieldPrint() method.
  • Changed ESMF_GridSetShapeTile() to ESMF_GridSetCommitShapeTile(). In addition to just setting data the newly renamed Grid method now also does an internal commit.
  • Added deep copy overload to ESMF_ArrayCreate().
  • Implemented transpose mode for Array redistribution in ESMF_ArrayRedistStore().
  • Implemented factor option for Array redistribution in ESMF_ArrayRedistStore(). Now the user can multiply the source Array by a constant factor as part of the redistribution operation.
  • Implemented support for direct coupling between components via RouteHandle-based communications (e.g. ESMF_ArraySparseMatMul(), ESMF_ArrayRedist()).
  • Added ESMF_DirectCoupling system test.
  • Implemented general TK support in ESMF_ArraySparseMatMul(). This means that source Array, destination Array, and factor list arguments can be of different type and kind.
  • Implemented general TK support in ESMF_ArrayRedist(). This means that source Array, destination Array, and factor arguments can be of different type and kind.
  • Fixed zeroflag bug in ESMF_ArraySparseMatMul() that did not correctly initialize the destination Array.
  • Fixed bug in ESMF_ArrayScatter()/ESMF_ArrayGather() that would access not allocated or not associated array arguments.
  • Fixed TKR checking in ESMF_LocalArrayGetData().
  • Corrected string passing on internal inter-language interfaces. A symptom of the problem was the failure of ESMF_StringUTest.F90 on some x86_64 machines.
  • Added support for compiler XLF v11.1.
  • Added scalimpi option to Linux.intel.default.
  • Added scalimpi option to Linux.pgi.default.
  • Same as release ESMF_3_1_0 with the following exceptions:
    • Corrected string passing on internal inter-language interfaces. A symptom of the problem was the failure of ESMF_StringUTest.F90 on some x86_64 machines.
    • Fixed zeroflag bug in ESMF_ArraySparseMatMul().
  • On Tempest IRIX64 unit test ESMC_ClockEx.C fails intermittently for ESMF_ABI=64.
  • An XLC 8.0 compiler bug causes the IBM BlueGene/L to fail system test ESMF_DirectCouplingSTest.F90 and unit tests ESMF_ArrayArbIdxSMMUTest.F90 and ESMF_ArrayRedistUTest.F90 for ESMF_BOPT=O.
  • On x86_64 systems using the medium-memory model with PGI 6.2-3 the ESMF_ArrayScatterUTest.F90 unit test fails.
  • Also see SourceForge bugs list.
ESMF_2_2_2rp3

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		2/4/08
  • Added support for Cray XT3/4 systems with CNL kernel.
  • Added scalimpi option to Linux.intel.default and Linux.pgi.default configurations. This has only been tested with the intel compiler.
  • Corrected string passing on internal inter-language interfaces. A symptom of the problem was the failure of ESMF_StringUTest.F90 on some x86_64 machines.
  • Same as release ESMF_2_2_2r.
  • PGI compiler 7.1-3 fails 4 examples and several TimeManager and LogErr unit tests.
  • Also see SourceForge bugs list.
ESMF_3_1_0

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		11/29/07
  • List of ESMF interface changes since ESMF_3_0_3.
  • Field, Bundle, State, and Component classes are now built on new Grid and Array classes. Field and Bundle method arguments have significantly changed so that they more closely resemble those of Grid and Array.
  • The following classes were removed:
    • IGrid (in the InternGrid directory, which was also removed)
    • FieldDataMap
    • BundleDataMap
  • The InternArray class is no longer visible at public interfaces. It will be removed in a future release along with InternDG.
  • Added system test FieldSparseMatMul. This creates Fields and gets Arrays from them in order to perform an ESMF_ArraySparseMatMul() operation.
  • The following were disabled:
    • Field and Bundle communication methods and corresponding unit tests and examples
    • Many Field and Bundle get and set methods and corresponding unit tests and examples
    • System tests *except* for CompCreate, DistDir, ArraySparseMatMul, FieldSparseMatMul, ArrayRedist, and ArrayScatterGather. Other system tests have not yet been modified to work with updated Field and Bundle classes, and will be restored in a future release.
  • Further work on the new Grid class:
    • Grids can be created or set with a regular distribution.
    • Coordinate arrays can be less than the Grid's rank (e.g. rectilinear coordinates)
    • Grids can be serialized and deserialized (e.g. as part of a state reconcile operation)
    • Grids can be queried for information about a stagger location including local DE exclusive and computational bounds, computationalEdgeWidths, and undistributed bounds.
    • Grids can be queried for element counts in addition to lower and upper bound information.
  • The Grids have been altered to live entirely within the Array exclusive region to allow for smoother interaction with Array methods.
  • Stagger locations have also been changed to allow:
    • Comparisons between staggerlocs
    • The output of a string describing the staggerloc
  • Implemented ESMF_ArrayGather()
  • Implemented ESMF_ArrayRedist()
  • Implemented ESMF_ArraySet()
  • Support the use of precomputed ArraySparseMatMul RouteHandles with different actual Arrays.
  • Optimized performance of ESMF_ArraySparseMatMulStore().
  • Optimized performance of ESMF_ArraySparseMatMul().
  • Implemented Array replication along specified DistGrid dimensions.
  • Generalized ArraySparseMatMul to support general Array - DistGrid dimension mapping.
  • Generalized ArraySparseMatMul to support tensor term mixing.
  • Implemented a more flexible Array computational bounds scheme that allows a computational region that is smaller than the exclusive region.
  • Changed Array total widths to be relative to the Array computational region.
  • Added computationalEdgeLWidth and computationalEdgeUWidth arguments to ESMF_ArrayCreate() interfaces to allow special treatment of the edge.
  • Changed DistGrid basic elements from cells to elements.
  • Changed Array's dimmap and inverseDimmap arguments to distgridToArrayMap and arrayToDistGridMap, respectively.
  • Added LocalArray section to ESMF Reference Manual.
  • Added support for Intel compiler version 10.
  • Increased robustness of g95 and gfortran configurations on Linux and Darwin.
  • Added support for Cray XT3/4 systems with CNL kernel.
  • The only Use Test Case that currently builds is ESMF_SparseMatMul. Due to failures of the other UTCs it must be built and run separately, not from the collective UTC makefile.
  • The zeroflag=ESMF_TRUE option in the ESMF_ArraySparseMatMul() call is broken for Arrays that have total regions that are larger than the exclusive region. The symptom of this bug is that not all destination elements are reset to zero before adding the sparse matrix multiplication terms.
  • The ESMF_StateReconcile() call, generally used by couplers dealing with Components running on exclusive petLists, has an internal size limit (which will be addressed in a subsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 20, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile() .
  • C/C++ Component examples fail with the XLF and PGI compilers as well as for the Linux/absoftintel combination.
  • The documentation for ESMF_GetAttribute() and ESMF_SetAttribute() calls for multi-valued list Attributes does not show a required integer input "count" argument after the "name" argument. If the "count" argument, which represents the number of Attribute values, is inserted the call will work.
  • ESMF_LOG_SINGLE is known to be broken. The symptoms are platform dependent and may appear non-deterministic.
  • On IRIX64 the exhaustive unit tests compiled against MPI will intermittently hang when run in uni-PET mode if the ESMF library was built with ESMF_PTHREADS=ON. This issue does not show up when running the MPI version in multi-PET mode or when using the MPIUNI version in uni-PET runs. The issue disappears when the ESMF library is compiled with ESMF_PTHREADS=OFF (which is the default for IRIX64).
  • ESMF fails to build on Cray XT3/XT4 with PGI 6.2.5 with an internal compiler error.
  • On IBM AIX systems in 32-bit mode StateLimitUTest fails in uni-PET mode.
  • On x86_64 systems using the medium-memory model with PGI 6.2-3 or PathScale 2.4 ESMF_ArrayDataUTest.F90 will report two failures. These failures indicate a problem with the F90 dope vector and ESMF must be assumed unreliable under these conditions.
  • On x86_64 systems using the medium-memory model with PGI 6.2-3 the ESMF_ArrayLarrayEx.F90 fails.
  • On Cray X1 the ESMF_DistDir system test fails.
  • On IBM BlueGene/L ESMF_VMSendVMRecvUTest.F90 fails in uni-PET mode.
  • On Linux Lahey, a test in ESMF_ArrayDataUTest.F90 fails with ESMF_BOPT=g.
  • All NAG compiler combinations we tested (on Linux as well as on Darwin) show random run-time failures when ESMF is compiled in optimized mode and also when user code that links with ESMF is compiled in optimized mode. Consequently ESMF sets ESMF_OPTLEVEL to 0 (zero) by default when compiling ESMF with NAG and we advise NAG users to not use optimization on user code that links against the ESMF library.
  • On Linux intel 9.1 with mpich2, unit test ESMF_StringUTest.F90 fails with ESMF_BOPT=O.
  • On x86_64 systems with PGI 6.2-3 or PathScale 2.4, unit test ESMF_VMBarrierUTest.F90 fails intermittently.
  • Also see SourceForge bugs list.
ESMF_2_2_2rp2

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		10/22/07
  • Added code to work around a bug in current Intel compiler versions on the NASA Altix system known as Columbia. This leads to failures in State and Grid interfaces when compiled in debug mode. It is unclear at this time if this is a system specific problem or not.
  • Added support for Intel compiler version 10.
  • Added port for gfortran compiler on Linux.
  • Added port for gfortran compiler on Darwin.
  • Added port for g95 compiler on Darwin.
ESMF_3_0_3

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		7/27/07
  • List of ESMF interface changes since ESMF_3_0_2.
  • Renamed all references to Grids that existed in previous versions of the framework to IGrid and moved the class to an InternGrid directory. The IGrid class is deprecated and will be removed in a future release.
  • Created a new Grid class, which is still at an early stage of development. The new Grids can:
    • be 1D, 2D, 3D and higher dimensions
    • have multiple undistributed dimensions
    • hold curvilinear coordinates at multiple stagger locations.
    The user can now:
    • create a new Grid either with shortcut methods or incrementally
    • get parameters from the new Grid
    • set and get Grid coordinates from an ESMF Array
    • get a pointer to the memory holding the coordinates in the Grid
    • get array bound information for the coordinate arrays
    • destroy a new Grid.
  • The ESMF_ArraySparseMatMulStore() and ESMF_ArraySparseMatMul() methods were rewritten and improved performance and reduced memory usage are expected. The methods have the following new features:
    • support for distributed definition of factors
    • support for user-supplied arbitrary sequence indices via 1D DistGrid
    • support for ESMF_TYPEKIND_I4/I8/R4/R8
    • default initialization of destination Array to zero (can be overridden)
  • A collective ESMF_DistGridCreate() call was introduced that takes local lists of arbitrary sequence indices and returns a matching 1D DistGrid. This can be used in combination with the Array sparse matrix multiply to regrid unstructured grids.
  • The ESMF_DistGridGet() interface was massively updated to provide complete access to DistGrid information. The names of many of the arguments have changed.
  • The ESMF_ArrayCreate() calls now provide the "name" argument.
  • Many unimplemented methods will return the failure code ESMF_RC_NOT_IMPL. Validate methods are considered implemented if at least initialization checks are present.
  • Cygwin.g95.default and Cygwin.gfortran.default configurations were added.
  • Starting with this version of ESMF, support for PGI compilers has been limited to PGI versions >= 6.2. We will stop reporting ESMF known bugs for older PGI versions.
  • C/C++ Component examples fail with the XLF and PGI compilers as well as for the Linux/absoftintel combination.
  • The ESMF_StateReconcile() call, generally used by couplers dealing with Components running on exclusive petLists, has an internal size limit (which will be addressed in a subsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 20, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile() .
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_ArrayGather() are only expected to work on 2D grids with 2D data.
  • When ESMF_InternArray objects are created with a non-zero halo width, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • Overall, we have found that regridding using ESMF_InternArrayRegrid(), FieldRegrid(), and BundleRegrid() is not robust. We encourage customers interested in ESMF regridding to move to the ESMF_ArraySparseMatMul() approach while regrid methods are reworked.
  • The conservative regrid algorithm for full spheres, which includes special treatment of the poles, is largely untested and expected to produce errors.
  • The conservative regrid method for both regional and global grids produces incorrect results for PGI in MPIUNI mode.
  • The documentation for ESMF_GetAttribute() and ESMF_SetAttribute() calls for multi-valued list Attributes does not show a required integer input "count" argument after the "name" argument. If the "count" argument, which represents the number of Attribute values, is inserted the call will work.
  • ESMF_LOG_SINGLE is known to be broken. The symptoms are platform dependent and may appear non-deterministic.
  • On IRIX64 the exhaustive unit tests compiled against MPI will intermittently hang when run in uni-PET mode if the ESMF library was built with ESMF_PTHREADS=ON. This issue does not show up when running the MPI version in multi-PET mode or when using the MPIUNI version in uni-PET runs. The issue disappears when the ESMF library is compiled with ESMF_PTHREADS=OFF (which is the default for IRIX64).
  • On Cray X1, the conservative regrid method does not work when the grid is defined as a uniform horizontal LatLon grid with periodic longitude coordinate and the source and destination grid are of the same size.
  • ESMF fails to build on Cray XT3/XT4 with PGI 6.2.5 with an internal compiler error.
  • On IBM AIX systems in 32-bit mode StateLimitUTest fails in uni-PET mode.
  • On x86_64 systems using the medium-memory model with PGI 6.2-3 or PathScale 2.4 ESMF_ArrayDataUTest.F90 will report two failures. These failures indicate a problem with the F90 dope vector and ESMF must be assumed unreliable under these conditions.
  • On x86_64 systems using the medium-memory model with PGI 6.2-3 the ESMF_ArrayLarrayEx.F90 fails.
  • On Cray X1 the ESMF_DistDir system test fails.
  • On IBM BlueGene/L ESMF_VMSendVMRecvUTest.F90 fails in uni-PET mode.
  • On Linux Lahey, a test in ESMF_ArrayDataUTest.F90 fails with ESMF_BOPT=g.
  • All NAG compiler combinations we tested (on Linux as well as on Darwin) show random run-time failures when ESMF is compiled in optimized mode and also when user code that links with ESMF is compiled in optimized mode. Consequently ESMF sets ESMF_OPTLEVEL to 0 (zero) by default when compiling ESMF with NAG and we advise NAG users to not use optimization on user code that links against the ESMF library.
  • The documentation of the ESMF_ArraySparseMatMulStore() API incorrectly states that the returned "routehandle" argument can be used to perform ESMF_ArraySparseMatMul() on any Array pair that is DistGrid-conforming to the Array pair used during the ESMF_ArraySparseMatMulStore(). This feature is _not_ yet supported, i.e. currently the "routehandle" can only be used to perform ESMF_ArraySparseMatMul() between the Array pair for which it was precomputed.
  • Also see SourceForge bugs list.
ESMF_2_2_2rp1

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		6/15/07
  • Added port for x86_64 ABI to Linux.intel.default.
  • Added port for x86_64 ABI to Linux.absoft.default.
  • Added PGI 7.x support for Linux and Cray XT3/4.
  • Fixed build file issue that caused problems with GNU Make 3.81.
  • Fixed memory leak in non-blocking VM communications.
  • Replaced the ESMF_NONBLOCKING option section in the Reference Manual with a more thorough explanation.
ESMF_3_0_2

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		5/25/07
  • List of ESMF interface changes since ESMF_3_0_1.
  • The ESMF_ArrayCreate(), ESMF_ArrayGet() and ESMF_ArrayScatter() interfaces were type/kind/rank overloaded.
  • ESMF_VMScatterV() and ESMF_VMGatherV() calls were added.
  • Methods across the framework had their return codes initialized to not implemented (ESMF_RC_NOT_IMPL). This is a step towards ensuring that unimplemented code returns appropriate errors when called.
  • LogErr calls were modified so that they need not set return codes prematurely to ESMF_SUCCESS. This is also a step towards ensuring that unimplemented code returns appropriate errors when called. This new LogErr behavior is not yet turned on, as there are still calls that rely on the former behavior of LogErr.
  • The declaration and usage of real and integer datatypes across the framework was standardized. The most significant change was the combination of type and kind into a single ESMF_TypeKind parameter. The new datatype conventions are included in the Developer's Guide.
  • A policy for the auto-promotion of user data via compile options was developed and is included in the Developer's Guide.
  • An ESMF_ConfigSetAttribute() call was implemented for 4-byte integers.
  • Conventions were established for a public ESMC optional argument API based on the variable-length argument list functionality provided by <stdarg.h>.
  • Added C interfaces for Config class (ESMC_Config). The ESMC_ConfigSetAttribute method is present, but not implemented.
  • An advanced stub for a new testing control system for running exhaustive tests on regrid and redist, called the test_harness, has been added. It runs and parses trivial bundle and field redistribution test configurations.
  • Fixed a bug that required Log files to be explicitly closed by the user before calling ESMF_Finalize.
  • Users may now open, write and close multiple Log files.
  • C/C++ Component examples fail with the XLF and PGI compilers as well as for the Linux/absoftintel combination.
  • The ESMF_StateReconcile() call, generally used by couplers dealing with Components running on exclusive petLists, has an internal size limit (which will be addressed in a subsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 20, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile() .
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_ArrayGather() are only expected to work on 2D grids with 2D data.
  • When ESMF_InternArray objects are created with a non-zero halo width, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • Overall, we have found that regridding using ESMF_InternArrayRegrid(), FieldRegrid(), and BundleRegrid() is not robust. We encourage customers interested in ESMF regridding to move to the ESMF_ArraySparseMatMul() approach while regrid methods are reworked.
  • The conservative regrid algorithm for full spheres, which includes special treatment of the poles, is largely untested and expected to produce errors.
  • The conservative regrid method for both regional and global grids produces incorrect results for PGI in MPIUNI mode.
  • The documentation for ESMF_GetAttribute() and ESMF_SetAttribute() calls for multi-valued list Attributes does not show a required integer input "count" argument after the "name" argument. If the "count" argument, which represents the number of Attribute values, is inserted the call will work.
  • ESMF_LOG_SINGLE is known to be broken. The symptoms are platform dependent and may appear non-deterministic.
  • On IRIX64 the exhaustive unit tests compiled against MPI will intermittently hang when run in uni-PET mode if the ESMF library was built with ESMF_PTHREADS=ON. This issue does not show up when running the MPI version in multi-PET mode or when using the MPIUNI version in uni-PET runs. The issue disappears when the ESMF library is compiled with ESMF_PTHREADS=OFF (which is the default for IRIX64).
  • On Cray X1, the conservative regrid method does not work when the grid is defined as a uniform horizontal LatLon grid with periodic longitude coordinate and the source and destination grid are of the same size.
  • On Cray XT3/XT4, the ESMF_VMBarrierUTest is incorrectly reported as failing. The origin of this problem seems to be a bug in Cray's implementation of MPI_Wtime(). This problem will also affect the validity of ESMF_VMWtime().
  • ESMF fails to build on Cray XT3/XT4 with PGI 6.2.5 with an internal compiler error.
  • On IBM AIX systems in 32-bit mode StateLimitUTest fails in uni-PET mode.
  • On x86_64 systems using the medium-memory model with PGI 6.2-3 or PathScale 2.4 ESMF_ArrayDataUTest.F90 will report two failures. These failures indicate a problem with the F90 dope vector and ESMF must be assumed unreliable under these conditions.
  • On IBM BlueGene/L, tests in ESMF_ClockUTest.F90 fail for ESMF_BOPT=O/g. Fails ESMF_VMSendVMRecvUTest.F90 in uni-PET mode.
  • On Linux Lahey, a test in ESMF_ArrayDataUTest.F90 fails with ESMF_BOPT=g.
  • All NAG compiler combinations we tested (on Linux as well as on Darwin) show random run-time failures when ESMF is compiled in optimized mode and also when user code that links with ESMF is compiled in optimized mode. Consequently ESMF sets ESMF_OPTLEVEL to 0 (zero) by default when compiling ESMF with NAG and we advise NAG users to not use optimization on user code that links against the ESMF library.
  • On the PGI 5.0-2 compiler with mpiuni, five regriding unit tests fail.
  • On the PGI 6.1-1 compiler with mpiuni, multiple unit tests, examples and 2 system tests fail.
  • Also see SourceForge bugs list.
ESMF_3_0_1

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		2/28/07
  • List of ESMF interface changes since ESMF_3_0_0.
  • Standardized the checking of initialization in ESMF. This introduces two new error return codes. The first, ESMF_RC_OBJ_NOT_CREATED, is returned if the user attempts to use a deep class variable without first creating it. The second ESMF_RC_OBJ_DELETED is returned if the user attempts to use a deep class variable after its deletion. Also, before this change, shallow class variables were not initialized on platforms with compilers that didn't support type component initialization. Now this initialization is handled by ESMF. Implementing this change necessitated the change of the intents of shallow class input parameters throughout ESMF from strictly in to inout.
  • Added an ESMF_LOG_NONE option to the "defaultLogType" argument of ESMF_Initialize() to turn off ESMF's default error logging.
  • Added "mpiCommunicator" argument to ESMF_Initialize() to allow ESMF to be initialized on a subset of MPI processes. The added VM example ESMF_VMUserMpiCommEx.F90 tests this new feature.
  • Added an ESMF_KEEPMPI option to the "terminationflag" argument of ESMF_Finalize() to allow ESMF finalization without MPI shutdown.
  • Removed deprecated GridCompCreate() and CplCompCreate() interfaces.
  • Optimized ESMF_BundleRedistStore(), ESMF_BundleRedist(), ESMF_FieldRedistStore(), and ESMF_FieldRedist() for arbitrarily distributed grids. A new algorithm was implemented i n the ESMF Route code to initialize the arbitrary to arbitrary grid redistribution. The redist run routine has been optimized specifically for the Cray X1 machine.
  • Added ESMF_VMAllGatherV() and VMAllToAllV() methods.
  • Added "errorMask" argument to ESMF_LogSet() to allow masking of error codes in LogErr handling.
  • Reworked the build system to be more robust and portable. Some of the previously used environment variables have become obsolete or were replaced by new variables. A full list of the environment variables as well as build system details can be found in the User's Guide. The main README contains enough information to get started quickly.
  • Introduced enhanced support for compiling and linking user applications against ESMF. See the User's Guide or main README for details.
  • Added a section to the User's Guide on how to port ESMF to other platforms.
  • Ported ESMF to the Cray XT3/XT4 and IBM BlueGene/L.
  • Added the following system tests to test the Bundle and Field redistribution methods for both arbitrarily distributed grids and block distributed grids:
    • ESMF_BundleRedistArb2ArbSTest.F90
    • ESMF_BundleRedistBlk2ArbSTest.F90
    • ESMF_BundleRedistBlk2BlkSTest.F90
    • ESMF_FieldRedistArb2ArbSTest.F90
    • ESMF_FieldRedistBlk2ArbSTest.F90
    • ESMF_FieldRedistBlk2BlkSTest.F90
  • Augmented the exhaustive regrid unit test ESMF_RegridToolUTest.F90 to include regrid scenarios with different resolution source grid and destination grid.
  • Fixed ESMF_InternArrayUTest unit test failures on the Linux PGI compiler.
  • The problem with PGI 6.1.1 on Linux was resolved as a consequence of the reworked build system.
  • The following issues appear to be resolved due to compiler upgrades or indirectly as a result of other development:
    • Problem building with XL Fortran compiler version 8.1.1.6, when compiling with the combination ESMF_PREC=64 and ESMF_BOPT=g.
    • Issues with configuration of MPICH with Intel 8.1.
  • The rank check error that incorrectly occurred during redistribution of Fields or Bundles that are transferred from block to arbitrary distribution (and vice versa) has been corrected.
  • The ESMF distribution available for download on the ESMF website has been pruned of many extraneous files, and is no longer bundled with documentation files. The distribution has been reduced in size from about 127MB to 12MB. Users can get documentation files by downloading from SourceForge.
  • This ESMF release is under the University of Illinois-NCSA Open Source License. Licenses are still a subject of discussion.
  • C/C++ Component examples fail with the XLF and PGI compilers as well as for the Linux/absoftintel combination.
  • The ESMF_StateReconcile() call, generally used by couplers dealing with Components running on exclusive petLists, has an internal size limit (which will be addressed in a su bsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 20, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile().
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_ArrayGather() are only expected to work on 2D grids with 2D data.
  • When ESMF_InternArray objects are created with a non-zero halo width, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • Overall, we have found that regridding using ESMF_InternArrayRegrid(), FieldRegrid(), and BundleRegrid() is not robust. We encourage customers interested in ESMF regridding to move to the ESMF_ArraySparseMatMul() approach while regrid methods are reworked.
  • On IRIX64 the exhaustive unit tests compiled against MPI will intermittently hang when run in uni-PET mode if the ESMF library was built with ESMF_PTHREADS=ON. This issue does not show up when running the MPI version in multi-PET mode or when using the MPIUNI version in uni-PET runs. The issue disappears when the ESMF library is compiled with ESMF_PTHREADS=OFF (which is the default for IRIX64).
  • The conservative regrid algorithm for full spheres, which includes special treatment of the poles, is largely untested and expected to produce errors.
  • The conservative regrid method for both regional and global grids produces incorrect results for PGI in MPIUNI mode.
  • The documentation for ESMF_GetAttribute() and ESMF_SetAttribute() calls for multi-valued list Attributes does not show a required integer input "count" argument after the "name" argument. If the "count" argument, which represents the number of Attribute values, is inserted the call will work.
  • ESMF_LOG_SINGLE is known to be broken. The symptoms are platform dependent and may appear non-deterministic.
  • On Cray X1, the conservative regrid method does not work when the grid is defined as a uniform horizontal LatLon grid with periodic longitude coordinate and the source and destination grid are of the same size.
  • On Cray X1, there are unit test failures across a wide range of classes, including Time classes, Field, State and Array, and we do not consider the release to be supported on this platform.
  • On Cray XT3/XT4, the ESMF_VMBarrierUTest is incorrectly reported as failing. The origin of this problem seems to be a bug in Cray's implementation of MPI_Wtime(). This problem will also affect the validity of ESMF_VMWtime().
  • On Cray XT3/XT4, the system test ESMF_ArraySparseMatMulSTest() and example ESMC_AppMainEx.C fail for ESMF_BOPT=O/g. System test ESMF_FieldHaloSTest() fails with ESMF_BOPT=O.
  • On IBM BlueGene/L, tests in ESMF_ArrayScatterUTest.F90 fail for ESMF_BOPT=g. Tests in ESMF_ClockUTest.F90 fail for ESMF_BOPT=O/g.
  • All NAG compiler combinations we tested (on Linux as well as on Darwin) show random run-time failures when ESMF is compiled in optimized mode and also when user code that links with ESMF is compiled in optimized mode. We advise NAG users to set environment variable ESMF_OPTLEVEL to 0 (zero) when compiling ESMF and to not use optimization on user code that links against the ESMF library.
  • Also see SourceForge bugs list.
ESMF_2_2_2r

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		12/1/06
  • List of ESMF interface changes since ESMF_2_2_2.
  • This is the first ESMF release under the University of Illinois-NCSA Open Source License. Subsequent releases will be under this license.
  • Added an ESMF_LOG_NONE option to the "defaultLogType" argument of ESMF_Initialize() to turn off ESMF's default error logging.
  • Added an ESMF_KEEPMPI option to the "terminationflag" argument of ESMF_Finalize() to allow ESMF finalization without MPI shutdown.
  • Fixed the C/C++ interfaces for all but XLF and PGI compilers, and reactivated the C/C++ Component interface examples.
  • Optimized ESMF_BundleRedistStore(), ESMF_BundleRedist(), ESMF_FieldRedistStore(), and ESMF_FieldRedist() for arbitrarily distributed grids. A new algorithm was implemented in the ESMF Route code to initialize the arbitrary to arbitrary grid redistribution. The redist run routine has been optimized specifically for the Cray X1 machine. View performance report.
  • Added an ESMF_VMAllGatherV() method.
  • Reworked the build system to be more robust and portable. Some of the previously used environment variables have become obsolete or were replaced by new variables. A full list of the environmentvariables as well as build system details can be found in the User's Guide. The main README contains enough information to get started quickly.
  • Introduced enhanced support for compiling and linking user applications against ESMF. See the User's Guide or main README for details.
  • Added a section to the User's Guide on how to port ESMF to other platforms.
  • Ported ESMF to the Cray XT3, IBM BlueGene/L and Darwin xlfgcc.
  • Added the following system tests to test the Bundle and Field redistribution methods for both arbitrarily distributed grids and block distributed grids:
    • ESMF_BundleRedistArb2ArbSTest.F90
    • ESMF_BundleRedistBlk2ArbSTest.F90
    • ESMF_BundleRedistBlk2BlkSTest.F90
    • ESMF_FieldRedistArb2ArbSTest.F90
    • ESMF_FieldRedistBlk2ArbSTest.F90
    • ESMF_FieldRedistBlk2BlkSTest.F90
  • Augmented the exhaustive regrid unit test ESMF_RegridToolUTest.F90 to include regrid scenarios with different resolution source grid and destination grid.
  • Fixed unit test failures on the Linux PGI compiler:
    • ESMF_ArrayUTest.F90
    • ESMF_VMBarrierUTest.F90
  • On the Linux Lahey compiler, fixed failure of the unit test ESMF_VMSendNbVMRecvNbUTest.F90.
  • Added support for the LSF batch queuing system.
  • The following issues appear to be resolved due to compiler upgrades or indirectly as a result of other development:
    • Problem building with XL Fortran compiler version8.1.1.6, when compiling with the combination ESMF_PREC=64 and ESMF_BOPT=g.
    • Intermittent failure of the "ESMF_FlowWithCoupling" system test and the "ESMF_COUPLED_FLOW" demo on AIX.
    • On the Linux PGI 5.0-2 compiler, failure of the "ESMF_FlowWithCoupling" system test and the "ESMF_COUPLED_FLOW" demo to compile with -g, resulting in an internal compiler error.
    • Issues with configuration of MPICH with Intel 8.1.
  • C/C++ Component examples fail with the XLF and PGI compilers.
  • The ESMF_StateReconcile() call, generally used by couplers dealing with concurrently running Components, has an internalsize limit (which will be addressed in a subsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 20, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile().
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_ArrayGather() are only expected to work on 2D grids with 2D data.
  • When ESMF_Array objects are created with a non-zero halo width, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • Overall, we have found that regridding using ArrayRegrid(), FieldRegrid(), and BundleRegrid() is not robust. We encourage customers interested in ESMF regridding to move to the ESMF_ArraySparseMatMul() approach in the ESMF 3 series while regrid methods are reworked.
  • The conservative regrid algorithm for full spheres, which includes special treatment of the poles, is largely untested and expected to produce errors.
  • The conservative regrid method for both regional and global grids produces incorrect results for PGI in MPIUNI mode.
  • On Cray X1, the conservative regrid method does not work when the grid is defined as a uniform horizontal LatLon grid with periodic longitude coordinate and the source and destination grid are of the same size.
  • On Cray XT3, the ESMF_VMBarrierUTest is incorrectly reported as failing. The origin of this problem seems to be a bug in Cray's implementation of MPI_Wtime(). This problem will also affect the validity of ESMF_VMWtime().
  • 'ESMF_LOG_SINGLE' is known to be broken. The symptoms are platform dependent and may appear non-deterministic.
  • All NAG compiler combinations we tested (on Linux as well as on Darwin) show random run-time failures when ESMF is compiled in optimized mode and also when user code that links with ESMF is compiled in optimized mode. We advise NAG users to set environment variable ESMF_OPTLEVEL to 0 (zero) when compiling ESMF and to not use optimization on user code that links against the ESMF library.
  • Darwin absoft version 8.2 fails unit test ESMF_CalRangeUTest.F90.
  • Also see SourceForge bugs list.
ESMF_3_0_0

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		5/20/06
  • List of ESMF interface changes since ESMF_2_2_2.
  • The following classes were modified to implement an index space layer according to JST design discussions:
    • Array
    • DELayout
    • DistGrid
  • Adjusted library sources, examples and tests to DELayout changes.
  • Added support for arbitary to arbitrary redistribution of Fields and Bundles.
  • Renamed previous Array class to InternArray. This class is expected to become an internal class in future releases.
  • Adjusted library sources, examples and tests to InternArray. Removed as many InternArray dependencies as possible.
  • Fixed VMBarrierUTest for PGI (Argonne Jazz cluster). This was a known bug in the previous release.
  • Fixed the C++ Component interface for most platforms. PGI and XLF still do not work.
  • Re-enable the C++ Component examples, which were disabled for the previous release.
  • Modified VMKernel and makefiles to allow compilation on NEC SX.
  • Added support for the LSF batch queueing system on the AIX platform. (For NCAR computer users, this supports 'bluevista'.)
  • The ESMF_StateReconcile() call, generally used by couplers dealing with concurrently running Components, has an internal size limit (which will be addressed in a subsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 20, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile().
  • Redistribution of Fields or Bundles that are transferred from block to arbitrary distribution (and vice versa) fails with a message about mismatched ranks.
  • The C/C++ Component examples fail with the XLF and PGI compilers.
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_InternArrayGather() are only expected to work on 2D grids with 2D data.
  • The conservative regrid algorithm for full spheres, which includes special treatment of the poles, is largely untested and expected to produce errors.
  • When ESMF_InternArray objects are created with a non-zero halo width, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • On AIX systems the ESMF fails to build with the XL Fortran compiler version 8.1.1.6, when compiling with the combination ESMF_PREC=64 and ESMF_BOPT=g. (Compiler version 8.1.1.4 works fine with all compile options, and ESMF_PREC=32 or ESMF_BOPT=O also work with either compiler version.)
  • When compiling with Intel 8.1 and using MPICH, make sure the Intel/MPICH libraries are configured with: #define MPI2CPP_HAVE_BOOL 1 which may not be the default output from configure.
  • On the Linux PGI compiler unit test ESMF_InternArrayUTest.F90 fails with both ESMF_BOPT=O/g
  • Build fails on Longs Linux PGI 6.1.1 compiler with ESMF_BOPT=g.
  • On the Cray X1, several system tests, examples and unit tests fail.
  • All NAG compiler combinations we tested (on Linux as well as on Darwin) show random run-time failures when ESMF is compiled in optimized mode and also when user code that links with ESMF is compiled in optimized mode. We advise NAG users to set environment variable ESMF_OPTLEVEL to 0 (zero) when compiling ESMF and to not use optimization on user code that links against the ESMF library.
  • Also see SourceForge bugs list.
ESMF_2_2_2

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		3/16/06
  • The ESMF_FieldExclSTest system test has been modified to demonstrate a simplified run loop for the concurrent case. This simplification was made possible by the modified blocking behavior of Components that was introduced with ESMF release 2.2.1.
  • Fixed a copy in/out problem on the F90/C VM interface. On Linux using the Lahey f95 compiler this problem had caused the non-blocking VM communication calls to send/receive from/into invalid data buffers, resulting in corrupt communication results.
  • The top level README has been updated to include more information about linking applications and porting ESMF to other platforms.
  • Added an optional environment variable, ESMF_ARRAY_LITE, to restrict the number of array-level interfaces automatically generated. This is required on the NEC build since single byte integer arrays are not supported on that platform, but is available as a general feature to reduce the number of overloaded interfaces and code size.
  • Added additional environment variables, ESMF_CXX_LIBRARY_PATH and ESMF_F90_LIBRARY_PATH, to support explicit library search paths. If defined, these will be used at link time to locate the correct F90 and C++ libraries. Otherwise, the standard LD_LIBRARY_PATH will be used.
  • Added "Appendix B: ESMF Error Return Codes" to the ESMF Reference Manual.
 Same as release ESMF_2_2_1 with the exception that ESMF_VMSendNbVMRecvNbUTest.F90 unit test no longer fails on the Linux Lahey compiler. Also see the SourceForge bugs list.
ESMF_2_2_1

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		2/14/06
  • List of ESMF interface changes since ESMF_2_2_0rp1
  • Changed the following in the ESMF_GridCompCreate() and ESMF_CplCompCreate() interfaces:
    • Added an interface with all optional arguments. In subsequent releases this may become the only supported interface.
    • We recommend that users call ESMF_xxxCompCreate() without specifying the parent VM. All tests, examples and demo codes have been modified to match the new convention.
    • If the parent VM is not specified the current VM is used as the parent VM (previously the global VM was used in this case).
  • Added support for high level MPMD. This makes xxxCompCreate() collective across all parent PETs and xxxCompSetServices() collective only across participating parent PETs.
  • Added a new blockingFlag for xxxCompInitialze(), xxxCompRun() and xxxCompFinalize() that eliminates some unnecessary synchronization points. This flag (ESMF_VASBLOCKING) is now the default.
  • The ESMF_StateReconcile() method no longer dumps core when the buffer size is exceeded. It returns an error message instead. (Please see the first item in the Known Bugs column.)
  • DELayout now issues warning if non 1-to-1 DELayouts or non logically rectangular DELayouts are created since most of the rest of the system does not handle these yet.
  • The Field and Bundle level redistribution communication calls have been rewritten. They now include 3+D data support and optimized communication calls for Bundles which contain Fields where the data arrays are congruent (same data type, same rank, etc).
  • Validate routines have been added for the Field and Bundle levels of the regrid, halo, and redistribution routines. If a hang or core dump appears to be associated with a call to the run routine for these operations, the route handle can be passed to a Validate routine which looks for inconsistencies and other problems.
  • Added full Fortran interface access to the non-blocking VM communications calls:
    • ESMF_VMSend()
    • ESMF_VMRecv()
    • ESMF_VMSendRecv()
    • ESMF_VMScatter()
    • ESMF_VMGather()
    • ESMF_VMReduce()
    • ESMF_VMAllGather()
    • ESMF_VMBroadcast()
  • Configuration attributes can be validated.
  • Configuration attributes can be checked for uniqueness. The "unique" argument in ESMF_ConfigLoadFile() now works.
  • Configuration files may contain logical attribute values.
  • LogErr no longer opens/closes logfile upon each write, enhancing performance.
  • The Log message length increased to 256 characters.
  • All Log messages (originating in either C++ or Fortran) go through Fortran for consistent, ordered output.
  • Time Manager defaults for any year, month, day calendar:
    • year = 0
    • month = 1
    • day =1
  • Improved regrid unit test structure to facilitate increasing test coverage.
  • Added system tests for MPMD (these are not automatically run by test scripts).
  • Added a unit test VMUserMpiInitUTest which checks that the user can explicitly call MPI_Init() before ESMF_Initialize().
  • Added unit tests for non-blocking VM communications.
  • Added support for the LSF batch queueing system on the AIX platform. (For NCAR computer users, this supports 'bluevista'.)
  • The files 'esmfuser.mk' and 'makefile.sample' in $ESMF_DIR/build replace the outdated 'link_rules.mk' files, showing how to link a user application with the ESMF library for any platform.
  • Added MPICH2 and IntelMPI support for Linux.intel.
  • The default linker front end on IRIX64 has been changed to CC, i.e. MIPSPro C++, for all ESMF applications. CC is now being used during link time regardless of the language in which the main program was written (Fortran90 or C++). In previous ESMF releases the f90 linker front end had been used to link applications on IRIX64 that provided the main program in Fortran. However, this led to problems during link time for applications that also contained C++ user code.
  • More documentation was added to the implementation notes part of the communication routines section.
  • Documented non-blocking features and limitations.
  • Added extensive new documentation on Grids and regridding.
  • Added reference documentation explaining that ESMF_CAL_NOCALENDAR does not track days, since the unit of a day is planet-specific.
  • The ESMF_StateReconcile() call, generally used by couplers dealing with concurrently running Components, has an internal size limit (which will be addressed in a subsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 20, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile().
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_ArrayGather() are only expected to work on 2D grids with 2D data.
  • The conservative regrid algorithm for full spheres, which includes special treatment of the poles, is largely untested and expected to produce errors.
  • When ESMF_Array objects are created with a non-zero halo width, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • The C/C++ Component interface is broken, so the C++ examples have been removed from the makefiles for this release.
  • On AIX systems there is a problem in the XL Fortran compiler version 8.1.1.6, when compiling with the combination ESMF_PREC=64 and ESMF_BOPT=g. (Compiler version 8.1.1.4 works fine with all compile options, and ESMF_PREC=32 or ESMF_BOPT=O also work with either compiler version.)
  • On AIX the "ESMF_FlowWithCoupling" system test and the "ESMF_COUPLED_FLOW" demo fail intermittently.
  • On the Linux PGI 5.0-2 compiler the "ESMF_FlowWithCoupling" system test and the "ESMF_COUPLED_FLOW" demo fail to compile with -g, resulting in an internal compiler error. (PGI 5.2-4 works fine)
  • When compiling with Intel 8.1 and using MPICH, make sure the Intel/MPICH libraries are configured with: #define MPI2CPP_HAVE_BOOL 1 which may not be the default output from configure.
  • Main programs in C/C++ do not work with the PGI compiler.
  • On the Linux PGI compiler the followingunit tests fail:
    • ESMF_ArrayUTest.F90
    • ESMF_VMBarrierUTest.F90
  • On the Linux Lahey compiler the ESMF_VMSendNbVMRecvNbUTest.F90 unit test fails.
  • Support for the LSF batch queueing system on the AIX platform needs script not included in the release.
  • All NAG compiler combinations we tested (on Linux as well as on Darwin) show random run-time failures when ESMF is compiled in optimized mode and also whe n user code that links with ESMF is compiled in optimized mode. We advise NAG users to set environment variable ESMF_OPTLEVEL to 0 (zero) when compiling ESMF a nd to not use optimization on user code that links against the ESMF library.
  • Also see SourceForge bugs list.
ESMF_2_2_0rp1

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		11/04/05
  • Fixed a bug in ESMF_StateReconcile() thatcaused memory corruption for objects containing attributes.
  • Modified an ESMF_StateReconcile() unit test to catch the bug described above.
  • Increased the size of the buffer used by ESMF_StateReconcile(), which caused a core dump if the buffer size was exceeded (this needs a better solution, but the patch will work for many users).
  • Removed all references to netcdf calls when ESMF_NO_IOCODE is set to true (due to conflicts between ESMF netcdf calls and user versions of the netcdf library)./li>
  • Fixed and documented an issue with MPICH that caused the working directory to be changed during the ESMF_Initialize() call. Now the API description of ESMF_Initialize() contains a paragraph discussing its dependency on MPI_Init() and the consequences thereof.
  • Added support for Intel 9.0 compilers on IA32 and IA64.
  • Same as release ESMF_2_2_0r with the exception of the ESMF_StateReconcile() bug.
  • Also see SourceForge bugs list.
ESMF_2_2_0r

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		07/13/05
  • List of ESMF interface changes since ESMF_2_1_1.
  • Fixed the following known bugs from previous releases:
    • Calling the redistribution and halo functions from a parent, coupler, or higher level Component fails on ESMF_Fields created in a child Component if that child is running on only a subset of the caller Component's PETs. This is the case, for example, when child Components are running concurrently.
    • Fixed the issue in the first-order conservative regrid sweep algorithm that calculated correct results but was inefficient.
  • Renamed dePetList argument in ESMF_DELayoutCreate() to petList to be more consistent with rest of the framework. Added more helpful comments describing the function of the petList argument.
  • Eliminated a bug in the VM setup which caused the sequence of PETs in the petList argument to ESMF_XXXCompCreate() to be ignored. Now the PETs of the child Component map to the parent PETs as is expected according to the petList sequence.
  • The initial phases of new code needed to optimize ESMF_Bundle level communication code have been added. An ESMF_Bundle which contains identically structured ESMF_Fields will only compute a single Route table and apply it to all ESMF_Fields. Later releases will include more optimizations inside the communication code itself.
  • The Log HALT_ON_ERROR function is now implemented.
  • In the Time Manager, ESMF_Clocks and ESMF_Alarms can now be run in reverse via a new optional ESMF_Direction type argument, which can have the values ESMF_MODE_REVERSE or ESMF_MODE_FORWARD in ESMF_ClockSet()/Get(). Forward mode is the default.
  • In the source tree, the Base directory was split into Base and Util, with utility routines which are not directly part of the Base class moved into the Util directory.
  • The default pointer size on Linux systems is now automatically determined using the output of the 'uname' command. 64-bit hardware defaults to ESMF_PREC 64, 32-bit hardware defaults to ESMF_PREC 32.
  • The ESMF_StateReconcile() call, generally used by couplers dealing with concurrently running Components, has an internal size limit (which will be addressed in a subsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 2, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile(). ESMF_StateReconcile() causes a core dump inthe buffer size is exceeded.
  • Calling ESMF_StateReconcile() for objects with attributes causes memory corruption.
  • The conservative regrid algorithm for full spheres, which includes special treatment of the poles, is largely untested and expected to produce errors.
  • When ESMF_Array objects are created with a non-zero halo width, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • The following Time Manager calendar conversions do not work: Gregorian <--> NoLeap <--> 360  Day.
  • Main programs in C/C++ do not work with the PGI compiler.
  • The ESMF_Bundle halo and redist functions must be called with ESMF_Bundles which contain identical ESMF_Field data types, rank, shape, and relative locations. Any other type of ESMF_Bundle will return with an ESMF_RC_NOT_IMPL error.
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_ArrayGather() are only expected to work on 2D grids with 2D data.
  • On the Cray X1:
    • The __LINE__ macro does not work in F90; "line 8" is always printed from methods such as ESMF_Test();
    • The ESMF_RowReduce system test, ESMF_LogErrEx.F90 and ESMFVMAllFullReduceEx.F90 examples and several unit tests fail.
  • On IRIX64:
    • The ESMF_LogErrUTest.F90 unit tests fail due to a difference in log file format as described in Sourceforge bug 1172026;
    • The ESMF_LogErrUTest.F90 crashes when attempting to read a log file in Fortran that was created in C as described in Sourceforge bug 1212893.
  • All NAG compiler combinations we tested (on Linux as well as on Darwin) show random run-time failures when ESMF is compiled in optimized mode and also when user code that links with ESMF is compiled in optimized mode. We advise NAG users to set environment variable ESMF_OPTLEVEL to 0 (zero) when compiling ESMF and to not use optimization on user code that links against the ESMF library.
  • On Darwin XLF compiler:
    • ESMF_FieldRegridMulti system test fails with ESMF_COMM=mpiuni;
    • Several examples fail with ESMF_COMM=lam and ESMF_BOPT=g;
    • ESMF_BundleCommUTest.F90 unit test fails with ESMF_BOPT=g and ESMF_COMM=mpiuni.
  • On AIX systems there is a problem in the XL Fortran compiler version 8.1.1.6, when compiling with the combination ESMF_PREC=64 and ESMF_BOPT=g. (Compiler version 8.1.1.4 works fine with all compile options, and ESMF_PREC=32 or ESMF_BOPT=O also work with either compiler version.)
  • When compiling with Intel 8.1 and using MPICH, make sure the Intel/MPICH libraries are configured with:
    #define MPI2CPP_HAVE_BOOL 1
    which may not be the default output from configure.
  • Also see SourceForge bugs list.
ESMF_2_1_1
Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		05/27/05
  • List of ESMF interface changes since ESMF_2_1_0rp3
  • More error checking added to the State routines.
  • Added the Abort option on ESMF_Finalize().
  • Fixed two regrid bugs for globally-indexed Fields:
    • Appeared in the bilinear regridding around domain edges on any processor except PE 0.
    • Appeared for 3D fields where the non-grid related index did not have a lower bound of one, for any regridding algorithm.
  • Additional regrid unit tests added.
  • ESMF_BundleRedistStore(), ESMF_FieldRedistStore() and ESMF_ArrayRedistStore() routines take a VMinstead of a DELayout.
  • Optional argument to select internal route data-packing and asychronous settings added to the ESMF_BundleRedistStore(), ESMF_FieldRedistStore() and ESMF_ArrayRedistStore() routines.
  • Halowidth removed from the ESMF_FieldCreate() calls where an already-created array is specified, which already contains halo information.
  • ESMF_VMAllGather() routine added.
  • Added option to create child Components which share the parent's VM.
  • Julian calendar added to Time Manager.
  • Added ESMF_CalendarIsLeapYear() and ESMF_TimeIsLeapYear() methods.
  • Additional internal packing options added to support different memory/ communication overhead ratios on different hardware platforms.
  • Extensive makefile and build system updates, including 64-bit PGI support, user-contributed g95 support, support for mpich on OSF (HP), updated make targets, and updated README's and User's Guide content.
  • It is now possible to compile ESMF withoutPthread dependency. If the environment variable ESMF_PTHREADS is set to OFF all Pthread dependent features of ESMF will be disabled. This can be used to simplify debugging and on systems that don't provide a functioning Pthread library. (This is different from the pthread-less default VM that was introduced in 2.1.0rp2!)
  • Compile-time options in system tests to run with threading enabled.
  • Output of unit and systems tests now go through the ESMF_Log facility, allowing multiprocessor test output to be cleanly collated.
  • Updated output scripts for results of unit and system tests.
  • More complete compiler and flag information printed for the output of 'gmake info'.
  • Site files need now only contain differences, not entire copies of the default makefiles.
  • Makefile target changes:
    • The previous default target was named 'all' but it only built libesmf. The current default target is named 'lib' and does the same thing. The new target 'all' builds the library and all the examples, tests, and demos.
    • The previous targets which were just 'tests' (e.g. build_tests) are now more specific: build_unit_tests, etc. There are new targets which are 'all_tests' to build everything.
    • Complete makefile target documentation may be found in the ESMF top level README file and in the User's Guide (subsection 6.2.3).
  • Added reference documentation about negative timesteps (as currently implemented, which is different from the upcoming reverse mode).
  • Expanded and updated the reference document bibliography, with citations.
  • The ESMF_StateReconcile() call, generally used by couplers dealing with concurrently running Components, has an internal size limit (which will be addressed in a subsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 2, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile(). ESMF_StateReconcile() causes a core dump if the buffer size is exceeded.
  • Calling ESMF_StateReconcile() for objects with attributes causes memory corruption.
  • Calling the redistribution and halo functions from a parent, coupler, or higher level Component fails on ESMF_Fields created in a child Component if that child is running on only a subset of the caller Component's PETs. This is the case, for example, when child Components are running concurrently. ESMF_FieldRegrid() does work correctly in this situation. Redistribution and halo functions work correctly when called from a child Component on ESMF_Fields created in that child Component.
  • The Log function "Halt on Error" has not been implemented, so we expect an error from the unit test ESMF_LogErrHaltUTest.F90 on all platforms. Log message is: FAILED, ESMF_LogErrHaltUTest.F90, line 96. The Halt on Error test failed.
  • The conservative regrid algorithm for full spheres, which includes special treatment of the poles, is largely untested and expected to produce errors. There is also some logic that is not correctly handling the situation where the physical domains of two Grids are slightly offset.  It does not result in errors or incorrect results but can be very inefficient.
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_ArrayGather() are only expected to work on 2D grids with 2D data.
  • When ESMF_Array objects are created with a non-zero halo width, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • The following Time Manager calendar conversions do not work: Gregorian <--> NoLeap <--> 360  Day.
  • On several platforms examples with a main in C/C++ do not link.These include Linux/Lahey, Linux/Absoft, Linux/PGI with mpiuni, and OSF1 (halem).
  • The operating system and all compilers on the Cray X1 at Ames were updated this week. There are problems running with the updated system; to run on the X1 follow the instructions for reverting back to the original environment, or contact us for help in running with the latest system.
  • The default compiler on the Compaq (halem), Fortran  551J, is compatible with this release. Fortran 551L core dumps when running system tests.
  • On AIX systems there is a problem in the XL Fortran compiler version 8.1.1.6, when compiling with the combination ESMF_PREC=64 and ESMF_BOPT=g. (Compiler version 8.1.1.4 works fine with all compile options, and ESMF_PREC=32 or ESMF_BOPT=O also work with either compiler version.)
  • When compiling with Intel 8.1 and using MPICH, make sure the Intel/MPICH libraries are configured with:
    #define MPI2CPP_HAVE_BOOL 1
    which may not be the default output from configure.
  • On the Cray X1, the __LINE__ macro does not work in F90; "line 8" is always printed from methods such as ESMF_Test().
  • The ESMF_VMAllFullReduceEx.F90 example fails on the Cray X1.
  • On the SGI IRIX64 with ESMF_PREC=32, all system tests pass but hang up with ESMF_PREC=64.
  • The ESMF_LogErrUTest.F90 unit tests fail on IRIX64 due to a difference in log file format as described in Sourceforge bug 1172026.
  • The ESMF_VMBarrierUTest.F90 unit test fails on Linux/NAG, Linux/Intel, Linux/PGI and Linux/Lahey platforms.
  • Also see SourceForge bugs list.
ESMF_2_1_0rp3
Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

Supported Platforms 		05/19/05
  • Fixed the known bug listed in release ESMF_2_1_0rp2:
    • Banding problem in bilinear regridding, at the bottom or left boundaries of some destination DEs (those bounding other DEs and not at domain edges in those directions), in regridding decompositions except R-to-C or C-to-R and under certain coordinate overlay circumstances.
  • Added unit tests to test more Regrid combinations and to verify that the above bug has been fixed.
  • Same as release ESMF_2_1_0rp2 with the exception of the bilinear regridding banding problem.
  • Also see SourceForge bugs list.
ESMF_2_1_0rp2

Reference Manual
(html (pdf)

User's Guide
(html) (pdf)
 03/11/05
  • Pthread-less default VM, i.e. the VMs of newly created Components will by default run without the use of threads.
  • Extended the command line argument code to correctly set options for ps(1) of BSD derived OSs, e.g. Darwin.
  • Fixed a problem with ESMF_StateReconcile() that would overwrite memory depending on the DELayout type. Sometimes no symptoms were evident and other times it would core dump. When the problem occurred, system test ESMF_FieldExcl would fail intermittently on the Linux platforms.
  • The performance for the redistribution function with arbitrarily distributed grids has been optimized.
  • The makefiles have been updated to support PGI 5.x, Absoft 9.x and NAG 5.x on Linux clusters.
  • Modified the command line Perl scripts so that now the number of passes and failures are printed as the last line of the script output instead of the first line.
  • Fixed bug in unit tests that falsely indicated that they were failing by relabeling tests that were mislabeled as non-exhaustive but were actually exhaustive. This problem occurred on all platforms. The following unit tests failed when run as non-exhaustive multi-processor:
    • ESMF_FRoute4UTest.F90
    • ESMF_FRoute8UTest.F90
    • ESMF_RegridUTest.F90
    • ESMF_TimeUTest.F90
  • The ESMF_StateReconcile() call, generally used by couplers dealing with concurrently running Components, has an internal size limit (which will be addressed in a subsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 2, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile(). ESMF_StateReconcile() causes a core dump if the buffer size is exceeded.
  • Calling ESMF_StateReconcile() for objects with attributes causes memory corruption.
  • Calling the redistribution and halo functions from a parent, coupler, or higher level Component fails on ESMF_Fields created in a child Component if that child is running on only a subset of the caller Component's PETs. This is the case, for example, when child Components are running concurrently. ESMF_FieldRegrid() does work correctly in this situation. Redistribution and halo functions work correctly when called from a child Component on ESMF_Fields created in that child Component.
  • Banding problem in bilinear regridding, at the bottom or left boundaries of some destination D Es (those bounding other DEs and not at domain edges in those directions), in regridding decompositions except R-to-C or C-to-R and under certain coordinate overlay circumstances.
  • ESMF_HaltType settings ESMF_LOG_HALTWARNING and ESMF_LOG_HALTERROR do not actually halt the code.
  • The default compiler on the Compaq (halem), Fortran 551J, is compatible with this release. Fortran 551L core dumps when running system tests.
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_ArrayGather() are only expected to work on 2D grids with 2D data.
  • When ESMF_Array objects are created with a non-zero halo width, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • On AIX systems there is a problem in the XL Fortran compiler version 8.1.1.6, when compiling with the combination ESMF_PREC=64 and ESMF_BOPT=g. (Compiler version 8.1.1.4 works fine with all compile options, and ESMF_PREC=32 or ESMF_BOPT=O also work with either compiler version.)
  • When compiling with Intel 8.1 and using MPICH, make sure the Intel/MPICH libraries are configured with:
    #define MPI2CPP_HAVE_BOOL 1
    which may not be the default output from configure.
  • Main programs in C/C++ do not work with the PGI compiler.
  • On the Cray X1, the __LINE__ macro does not work in F90; "line 8" is always printed from methods such as ESMF_Test().
  • The following Time Manager calendar conversions do not work: Gregorian <--> NoLeap <--> 360 Day.
  • On the Darwin XLF compiler:
    • Example ESMF_LogErrEx.F90 fails.
    • System test, ESMF_FieldRegridMulti uni fails with ESMF_BOPT=O and ESMF_COMM=mpiuni.
    • Several examples fail with ESMF_BOPT=g and ESMF_COMM=lam.
  • On the Linux PGI Compiler, 9 examples fail with ESMF_BOPT=g.
  • Also see SourceForge bugs list.
ESMF_2_1_0rp1
Reference Manual
(html) (pdf)

User's Guide
(html) (pdf) 		02/11/05
  • Concurrent Components run on the Altix and most Linux platforms now. Check the specific compiler release notes for any restrictions on supported compiler versions.
  • The Intel makefiles have been updated to support more compile-time configuration options.
  • A makefile target for running the demo uniprocessor was added (useful, for example, when ESMF is compiled with the mpiuni bypass libs.)  It is: ESMF_COUPLED_FLOW_uni
  • The output when building and running the unit tests, the examples, and the system tests has been improved.
  • Better defaults have been added to several Log interfaces, so the operations happen on the default Log if no user Log is specified.
  • Fixed problem that existed on halem linking applications with C main.
  • Added better diagnostic for when pthread_create fails because of limit settings.
  • Fixed an issue creating a Field from an allocated Fortran array.
  • Fixed the following Time Manager bugs:
    • Bug #1101904, "Disable stopTime to make clock run forever."
    • Bug #1113438, "getting dayOfYear should impose day boundary for getting hrs."
    • Bug #1118178, "ESMF_TimeGet returns string with %lld not %04lld."
  • The ESMF_StateReconcile() call, generally used by couplers dealing with concurrently running Components, has an internal size limit (which will be addressed in a subsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 2, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile(). ESMF_StateReconcile() causes a core dump if the buffer size is exceeded.
  • Calling ESMF_StateReconcile() for objects with attributes causes memory corruption.
  • Calling the redistribution and halo functions from a parent, coupler, or higher level Component fails on ESMF_Fields created in a child Component if that child is running on only a subset of the caller Component's PETs.  This is the case, for example, when child Components are running concurrently.  ESMF_FieldRegrid() does work correctly in this situation.  Redistribution and halo functions work correctly when called from a child Component on ESMF_Fields created in that child Component.
  • The default compiler on the Compaq (halem), Fortran  551J, is compatible with this release. Fortran 551L core dumps when running system tests.
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_ArrayGather() are only expected to work on 2D grids with 2D data.
  • When ESMF_Array objects are created with a non-zero halo width, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • On AIX systems there is a problem in the XL Fortran compiler version 8.1.1.6, when compiling with the combination ESMF_PREC=64 and ESMF_BOPT=g. (Compiler version 8.1.1.4 works fine with all compile options, and ESMF_PREC=32 or ESMF_BOPT=O also work with either compiler version.)
  • When compiling with Intel 8.1 and using MPICH, make sure the Intel/MPICH libraries are configured with:
     #define MPI2CPP_HAVE_BOOL 1
     which may not be the default output from configure.
  • Main programs in C/C++ do not work with the PGI compiler.
  • The ESMF_StateReconcile() call does not work with the Lahey compiler.  The ESMF_FieldExcl system test uses this call, so it will not work either.
  • On the Cray X1, the __LINE__ macro does not work in F90; "line 8" is always printed from methods such as ESMF_Test().
  • The ESMF_VMGetMPICommunicatorEx example fails on the Linux/intel 64-bit build.
  • The ESMF_StateUTest test fails on the Linux/PGI build.
  • The ESMF_StateEx example fails on the Linux/PGI build.
  • Several of the examples fail on the Mac OS X/xlf build.
  • The ESMF_StateUTest fails 2 tests on the Linux/absoft build
  • The following Time Manager calendar conversions do not work: Gregorian <--> NoLeap <--> 360  Day
  • Also see SourceForge bugs list.
ESMF_2_1_0r

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)
 01/14/05
  • Concurrent Component support has been added.  Component initialize, run, and finalize routines can be called with a flag which causes control to return immediately to the calling Component which can then start other Components in parallel.  Concurrency features are not yet operating correctly on Linux and Altix platforms (see Known Bugs).
  • Components can be created and run on a subset of the parent's Persistent Execution Threads, PETs. An ESMF_StateReconcile() call was added so that a parent Component can ensure that child Components who will be communicating each have all the State information that they need, even if Fields were not originally declared on both children.
  • Support for arbitrarily distributed grids and their redistribution to and from grids with block decompositions has been added.  This is currently very slow.
  • The issue with regrid that occasionally caused banding has been fixed.
  • The issue with regrid that occasionally returned NaNs on spherical coordinate systems has been fixed.
  • The issue with halo for periodic boundaries on non-decomposed axes has been fixed.
  • Problems with Route on PET counts that are not powers of 2 were fixed, and Route now works correctly for any PET count.
  • Some Field level communication routines now take a VM, not a DELayout.
  • Redist and regrid use asynchronous communications internally.
  • Support for concurrent Components has been activated in the VM.
  • Overhead when entering/exiting VM contexts has been reduced.
  • Conflicts between VM and MPICH's devices due to POSIX signal overlaps have been resolved.
  • New VM now works reliably with old, non-posix compliant (pre-NPTL) LinuxThreads, as well as POSIX compliant threads.
  • Internally added non-blocking communications to the VM to enhance RouteRun performance.
  • Several of the communication calls in the VM API have been overloaded to accept data of type 'ESMF_Logical' and 'Character'.
  • A new method ESMF_VMGetCurrent() has been added which can be used anywhere from within an ESMF application to obtain the current VM context without the need to provide any input information.
  • Component wait can now be called even on not currently running Components, in which case it will return immediately.
  • Buffering support has been added to LogErr. Writes to a Log now go through an adjustable buffer to improve performance.
  • Every entry in a Log now has the PET number prepended to the entry.
  • Multilog support has been added to LogErr. When the multilog option is set during Log initialization, separate Log files are created for the output from each PET.
  • Units of fractional seconds (specified with integers) are now supported within ESMF_Time and ESMF_TimeInterval.  The shortcut arguments ms, us, and ns (millisecond, microsecond, nanosecond) for Set()/Get() methods can be used as well as the more general arguments sN and sD (numerator, denominator).  Fractional seconds in Times and Time Intervals may fully participate in Clock, Alarm and Calendar objects and methods.  They also are fully functional within arithmetic (integer based) and comparison operations.
  • The following Time Manager bugs/enhancements have been fixed/done:
    • The Alarm limit per Clock is now dynamic in increments of 200.
    • ESMF_ClockPrint()/ESMF_TimePrint() now correctly adjusts for leap years.
    • The implicit day boundary in ESMF_TimeGet() has changed to a user-supplied boundary (fixed bug 1099731).
    • An Alarm will now ring immediately if its ring time is set equal to the Clock start time.
    • Can now drive No-Leap and 360-Day calendar-based times with seconds only.
    • Direct errors are now generated when dd < 1 or mm < 1 in ESMF_TimeSet().
    • Can now call ESMF_TimeSet() with only the dd argument; yy defaults to 0 and mm defaults to 1.
    • ESMF_ClockValidate() now works correctly after the end of an ESMF_ClockAdvance() loop.
  • The ESMF_StateReconcile() call, generally used by couplers dealing with concurrently running Components, has an internal size limit (which will be addressed in a subsequent release). There is no hard-coded limit to how many elements, i.e. States, Bundles, Fields, Arrays can be added to the State. However, there is a limit, roughly 2, on the maximum number of sub-elements contained by any element in the State passed into ESMF_StateReconcile(). ESMF_StateReconcile() causes a core dump if the buffer size is exceeded.
  • Calling ESMF_StateReconcile() for objects with attributes causes memory corruption.
  • Calling the redistribution and halo functions from a parent, coupler, or higher level Component fails on ESMF_Fields created in a child Component if that child is running on only a subset of the caller Component's PETs.  This is the case, for example, when child Components are running concurrently.  ESMF_FieldRegrid() does work correctly in this situation.  Redistribution and halo functions work correctly when called from a child Component on ESMF_Fields created in that child Component.
  • The default compiler on the Compaq (halem), Fortran  551J, is compatible with this release. Fortran 551L core dumps when running system tests.
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_ArrayGather() are only expected to work on 2D grids with 2D data.
  • When ESMF_Array objects are created with a non-zero halo width, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • On AIX systems there is a problem in the XL Fortran compiler version 8.1.1.6, when compiling with the combination ESMF_PREC=64 and ESMF_BOPT=g. (Compiler version 8.1.1.4 works fine with all compile options, and ESMF_PREC=32 or ESMF_BOPT=O also work with either compiler version.)
  • When compiling with Intel 8.1 and using MPICH, make sure the Intel/MPICH libraries are configured with:
     #define MPI2CPP_HAVE_BOOL 1
     which may not be the default output from configure.
  • Main programs in C/C++ do not work with the PGI compiler.
  • The ESMF_StateReconcile() call does not work on the Linux and Altix builds of ESMF.  The ESMF_FieldExcl system test uses this call, so it will not work on these platforms either.
  • On the Cray X1, the __LINE__ macro does not work in F90; "line 8" is always printed from methods such as ESMF_Test().
  • The ESMF_VMGetMPICommunicatorEx example fails on the Linux/intel 64-bit build.
  • The ESMF_StateUTest test fails on the Linux/PGI build.
  • The ESMF_StateEx example fails on the Linux/PGI build.
  • Several of the examples fail on the Mac OS X/xlf build.
  • The ESMF_StateUTest fails 2 tests on the Linux/absoft build.
  • Also see SourceForge bugs list.
ESMF_2_0_1

ReferenceManual
(html) (pdf)

User's Guide
(html) (pdf)

9/24/04
  • ESMF_ArrayGather() now works even when the individual Arrays aren't identical sizes. This also fixes problems with ESMF_ArrayWrite()/ESMF_FieldWrite().
  • Array object now sets halo width correctly (bug 995309).
  • ESMF_FieldSetDataPointer() routine fixed to correctly create an Array.
  • ESMF_FieldWrite() supports R8 data.
  • Bundle level communication routines added (loops over Fields).
  • Bundles now validate that the Grids match, and contain more error checking.
  • The src/Infrastructure/IO/src files no longer require preprocessing.
  • Regrid supports R4 data.
  • Regrid code now correctly handles Fields with non-zero halo widths.
  • LogError now buffers messages internally before flushing them to a file, and has updated documentation.
  • Config no longer triggers errors from Fortran OPEN() when the file has read-only file permissions.
  • Time manager bugs fixed:
    • Bug 1014766 fixed; "dayOfYear always returns 1."  (also fixed similar bug in dayOfWeek).
    • The maximum number of alarms per clock has been increased to 200, from 100 previously.
    • Bug 996229 fixed; "Non-sticky alarms not functioning properly".
  • Build and test fixes:
    • ESMF_BUILD fixed for building files in a different directory from the source.
    • Automated nightly unit tests now run multiprocessor on some platforms.
  • Documents now build without having to compile the library first.
  • More documentation added for Grid and Regrid functions.
  • The default compiler on the Compaq (halem), Fortran  551J, is compatible with this release. Fortran 551L core dumps when running system tests.
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_ArrayGather() are only expected to work on 2D grids with 2D data.
  • When ESMF_Array objects are created with a non-zero halo width, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • This release returns an internal compile error with the PGI/Linux compiler and ESMF_BOPT=g. It builds successfully with ESMF_BOPT=O.
  • There are known problems running with -O on Mac OS X compiling with absoft and running with lam mpi.  The workaround is to compile with ESMF_BOPT=g.
  • On AIX systems there is a problem in the XL Fortran compiler version 8.1.1.6, when compiling with the exact combination ESMF_PREC=64 and ESMF_BOPT=g. (Compiler version 8.1.1.4 works fine with all compile options, and ESMF_PREC=32 or ESMF_BOPT=O also work with either compiler version.)
  •  When compiling with Intel 8.1 and using MPICH, make sure the Intel/MPICH libraries are configured with:
    #define MPI2CPP_HAVE_BOOL 1
    which may not be the default output from configure.
  • Main programs in C/C++ do not work with the PGI compiler.
  • Routes will only work on PET counts that are powers of 2.
  • Some regrid results may show "banding" when regridding between decompositions where processor domains overlap only slightly.
  • Halo does not work correctly for periodic boundaries on non-decomposed axes.
  • Also see SourceForge bugs list.
ESMF_2_0_0rp3

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf) 		5/6/05
  • The following Regrid known bugs from the previous release have been fixed:
    • ESMF regrid functions operate only on R8 data. (It now operates on R4 and R8 data.)
    • ESMF regrid functions do not operate correctly on data with non-zero halo widths. 
    • Some regrid results may show some "banding" when regridding between decompositions where processor domains overlap only slightly.
  • Same as known bugs for ESMF_2_0_0rp2 excluding those listed in the Release Notes column.
  • Also see SourceForge bugs list.
ESMF_2_0_0rp2

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)
 7/26/04
  • All AddAttribute() routines have been renamed SetAttribute() to address problems with method semantics.
  • Support has been added for attribute types of I4, I8 and R4, R8, both single values and lists.
  • Support has been added for setting and getting attributes on Grid objects.
  • Two bugs have been fixed in the VM code:
    • On some MPICH environments VM ran with only one PET, regardless of the number specified on the mpirun command line.
    • Segmentation faults when using MPICH's P4 device.
  • The following TimeMgr bugs have been fixed:
    • The 20 TimeInterval unit test failures under the PGI compile caused by PGI's peculiarity on passing missing F90 optional args, as well as inconsistent F90 local variable initializer behavior.
    • Erroneous LogErr messages caused by a lack of F95 derived-type initializers on all platforms.
  • Main programs in C/C++ do not work with the PGI compiler.
  • All the system tests pass running single processor except ESMF_FieldRedist() with the lahey compiler and ESMF_BOPT=O.
  • When ESMF_Array objects are created with a non-zero halo width, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • ESMF regrid functions operate only on R8 data. 
  • ESMF regrid functions do not operate correctly on data with non-zero halo widths.
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_ArrayGather() are only expected to work on 2D grids with 2D data.
  • ESMF_FieldCreate() does not do sufficient error checking when given an already-existing ESMF_Array or allocated Fortran array pointer. Please see the examples in the Field directory.
  • Non-sticky alarms in Time Manager are not functioning properly.
  • ESMF_FieldGather() and ESMF_ArrayGather() only work correctly for evenly decomposed Grids.
  • When compiling with Intel 8.1 and using MPICH, make sure the Intel/MPICH libraries are configured with:
    #define MPI2CPP_HAVE_BOOL 1
    which may not be the default output from configure.
  • Routes will only work on processor counts that are powers of 2.
  • Some regrid results may show some "banding" when regridding between decompositions where processor domains overlap only slightly.
  • Halo does not work correctly for periodic boundaries on non-decomposed axes.
  • Also see SourceForge bugs list.
ESMF_2_0_0rp1

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)
 6/30/04
  • Added Mac xlf build.
ESMF_2_0_0r

Reference Manual
(html) (pdf)

User's Guide
(html) (pdf)

 6/23/04
  • Reference Manual and User's Guide reviewed and cleaned up.
  • ESMF_FieldWrite() working.
  • Main programs in C do not work with the PGI compiler.
  • All the system tests pass running single processor except ESMF_FieldRedist() with the lahey compiler and ESMF_BOPT=O.
  • When ESMF_Array objects are created with a non-zero haloWidth, that width is added to all dimensions of the array, not only ones which correspond to the decomposed grid axes.
  • ESMF regrid functions operate only on R8 data. 
  • ESMF regrid functions do not operate correctly on data with non-zero halo widths.
  • ESMF_BundleGather(), ESMF_FieldGather() and ESMF_ArrayGather() are only expected to work on 2D grids with 2D data.
  • ESMF_FieldCreate() does not do sufficient error checking when given an already-existing ESMF_Array or allocated Fortran array pointer. Please see the examples in the Field directory.
  • Problems with the VM:
    • On some MPICH environments VM ran with only one PET, regardless of the number specified on the mpirun command line.
    • Segmentation faults when using MPICH's P4 device.
  • Time Manager bugs:
    • Non-sticky alarms in Time Manager are not functioning properly.
  • ESMF_FieldGather() and ESMF_ArrayGather() only work correctly for evenly decomposed Grids.
  • Also see SourceForge bugs list.