SUNDIALS: SUite of Nonlinear and DIfferential/ALgebraic Equation Solvers

Release History

CVODE :: CVODES :: ARKODE ::  IDA :: IDAS
KINSOL :: sundialsTB

What’s New in SUNDIALS?

Changes in beta release SUNDIALS v.5.0.0-dev.1

Several new functions were added to aid in creating custom NVECTOR, SUNMATRIX, SUNLINEARSOLVER, and SUNNONLINEARSOLVER objects. The constructors N_VNewEmpty(), SUNMatNewEmpty(), SUNLinSolNewEmpty(), and SUNNonlinSolNewEmpty() allocate “empty” generic NVECTOR, SUNMATRIX, SUNLINEARSOLVER, and SUNNONLINEARSOLVER objects respectively with the object’s content pointer and the function pointers in the operations structure initialized to NULL. When used in the constructor for custom objects these functions will ease the introduction of any new optional operations to the NVECTOR, SUNMATRIX, SUNLINEARSOLVER, or SUNNONLINEARSOLVER APIs by ensuring only required operations need to be set. Additionally, the functions N_VCopyOps(w, v) and SUNMatCopyOps(A, B) have been added to copy the operation function pointers between vector and matrix objects respectively. When used in clone routines for custom vector and matrix objects these functions also will ease the introduction of any new optional operations to the NVECTOR or SUNMATRIX APIs by ensuring all operations are copied when cloning objects.

New linear solver interface functions ARKLsLinSysFn and CVLsLinSysFn were added as alternative methods for evaluating the matrix for the linear systems M - gamma J and I - gamma J respectively.

Fixed a bug in the build system that prevented the PThreads NVECTOR module from being built.

Fixed a bug in ARKStep where the mass matrix linear solver setup function was not called in the Matrix-free case.

Fixed a minor bug in ARKStep where an incorrect flag is reported when an error occurs in the mass matrix setup or Jacobian-vector product setup functions.

Fixed a memory leak in the NVECTOR_PETSC clone function.

Fixed memory leaks in FARKODE, FCVODE, and FIDA when not using the default nonlinear solver.

Fixed a bug in IDAQuadReInitB where an incorrect memory structure was passed to IDAQuadReInit.

Added two new embedded ARK methods of orders 4 and 5 to ARKode (from Kennedy & Carpenter, Appl. Numer. Math., 136:183–205, 2019).

The ManyVector NVECTOR module has been split into two versions: one that requires MPI (MPIManyVector) and another that does not use MPI at all (ManyVector).  The associated example problems have been similarly updated to reflect this new structure.

An additional NVECTOR implementation, NVECTOR_MPIPLUSX, was created to support the MPI+X paradigm where X is a type of on-node parallelism (e.g. OpenMP, CUDA). The implementation is accompanied by additions to user documentation and SUNDIALS examples.

The *_MPICuda and *_MPIRaja functions were removed from the NVECTOR_CUDA and NVECTOR_RAJA implementations respectively. Accordingly, the nvector_mpicuda.h,nvector_mpiraja.h, libsundials_nvecmpicuda.lib, and libsundials_nvecmpicudaraja.libfiles have been removed. Users should use the NVECTOR_MPIPLUSX module coupled with the NVECTOR_CUDA or NVECTOR_RAJA to replace the functionality. The necessary changes are minimal and should require few code modifications.

New Fortran 2003 interfaces to ARKODE, IDA, KINSOL, all generic SUNDIALS types (i.e. NVECTOR, SUNMATRIX, SUNLINEARSOLVER, SUNNONLINEARSOLVER), and the  NVECTOR_PARALLEL were added. These new interfaces were generated with SWIG-Fortran and provide a user an idiomatic Fortran 2003 interface to most of the SUNDIALS C API. The CVODE interface, and all module implementations with existing Fortran 2003 interfaces were updated accordingly. See the section  “Using <SOLVER> for Fortran Applications” in the appropriate user guide for more details on how to use the interfaces.

Removed extraneous calls to N_VMin() for simulations where the scalar valued absolute tolerance, or all entries of the vector-valued absolute tolerance array, are strictly positive.  In this scenario, CVODE(S), IDA(S) and ARKode will remove at least one global reduction per time step.

Changes in development release SUNDIALS v.5.0.0-dev.0

An additional N_Vector implementation, NVECTOR_MANYVECTOR, was created to support flexible partitioning of solution data among different processing elements (e.g., CPU + GPU) or for multi-physics problems that couple distinct MPI-based simulations together (see the NVECTOR_MANYVECTOR section in the user guides for more details). This implementation is accompanied by additions to user documentation and SUNDIALS examples.

Eleven new optional vector operations have been added to the N_Vector API to support the new NVECTOR_MANYVECTOR implementation (see N_Vector chapter is the user guides for more details). Two of the operations, N_VGetCommunicator and N_VGetLength, must be implemented by subvectors that are combined to create an NVECTOR_MANYVECTOR, but are not used outside of this context. The remaining nine operations are optional local reduction operations intended to eliminate unnecessary latency when performing vector reduction operations (norms, etc.) on distributed memory systems. The optional local reduction vector operations are N_VDotProdLocal, N_VMaxNormLocal, N_VMinLocal, N_VL1NormLocal, N_VWSqrSumLocal, N_VWSqrSumMaskLocal, N_VInvTestLocal, N_VConstrMaskLocal, and N_VMinQuotientLocal. If an N_Vector implementation defines any of the local operations as NULL, then the NVECTOR_MANYVECTOR will call standard N_Vector operations to complete the computation.

A new SUNMatrix and SUNLinearSolver implementation was added to facilitate the use of the SuperLU_DIST library with SUNDIALS.

A new operation, SUNMatMatvecSetup, was added to the SUNMatrix API. Users who have implemented custom SUNMatrix modules will need to at least update their code to set the corresponding ops structure member, matvecsetup, to NULL.

The generic SUNMatrix API now defines error codes to be returned by SUNMatrix operations. Operations which return an integer flag indicating success/failure may return different values than previously.

The MRIStep module has been updated to support explicit, implicit, or IMEX methods as the fast integrator using the ARKStep module. As a result some function signatures have been changed including MRIStepCreate which now takes an ARKStep memory structure for the fast integration as an input.

Changes in minor release SUNDIALS v.4.1.0

An additional N_Vector implementation was added for Tpetra vector from Trilinos library to facilitate interoperability between SUNDIALS and Trilinos. This implementation is accompanied by additions to user documentation and SUNDIALS examples.

A bug was fixed where a nonlinear solver object could be freed twice in some use cases.

The EXAMPLES_ENABLE_RAJA CMake option has been removed. The option EXAMPLES_ENABLE_CUDA enables all examples that use CUDA including the RAJA examples with a CUDA back end (if the RAJA NVECTOR is enabled).

The implementation header files (e.g. arkode_impl.h) are no longer installed. This means users who are directly manipulating package memory structures will need to update their code to use the package’s public API.

Python is no longer required to run make test and make test_install.

Fixed a bug in ARKodeButcherTable_Write when printing a Butcher table without an embedding.

Changes in patch release SUNDIALS v.4.0.2

Added information about how to contribute to SUNDIALS as well as a contributor agreement.

Moved definitions of DLS and SPILS backwards compatibility functions to a source file. The symbols are now included in the appropriate package library, e.g. libsundials_cvode.lib.

Changes in patch release SUNDIALS v.4.0.1

A bug in ARKode where single precision builds would fail to compile has been fixed.

Changes in major release SUNDIALS v.4.0.0

The direct and iterative linear solver interfaces in all SUNDIALS packages have been merged into unified linear solver interfaces for each package that support any valid SUNLINSOL module. This includes the previous DIRECT and ITERATIVE types and the new MATRIX_ITERATIVE type. Details regarding how SUNDIALS packages utilize linear solvers of each type as well as discussion regarding intended use cases for user-supplied SUNLINSOL implementations are included in the SUNLINSOL chapter of the user guides.

The unified interfaces are very similar to the previous DLS and SPILS interfaces. To minimize challenges in user migration to the unified linear solver interfaces, the previous DLS and SPILS routines for all packages may still be used; these will be deprecated in future releases, so we recommend that users migrate to the new names soon. Additionally, we note that Fortran users will need to enlarge their iout array of optional integer outputs, and update the indices that they query for certain linear-solver-related statistics.

The names of all constructor routines for SUNDIALS-provided SUNLinSol implementations have been updated to follow the naming convention SUNLinSol_* where * is the name of the linear solver e.g., Dense, KLU, SPGMR, PCG, etc. Solver-specific “set” routine names have been similarly standardized. To minimize challenges in user migration to the new names, the previous routine names may still be used; these will be deprecated in future releases, so we recommend that users migrate to the new names soon.

SUNDIALS integrators (ARKode, CVODE, CVODES, IDA, and IDAS) have been updated to utilize generic nonlinear solver modules through the SUNNONLINSOL API. This API will ease the addition of new nonlinear solver options and allow for external or user-supplied nonlinear solvers. The SUNNONLINSOL API and provided SUNNONLINSOL modules are described in a new user guide chapter and follow the same object oriented design and implementation used by the NVECTOR, SUNMATRIX, and SUNLINSOL modules.

With the introduction of SUNNonlinSol modules, the input parameter iter to CVodeCreate has been removed along with the function CVodeSetIterType and the constants CV_NEWTON and CV_FUNCTIONAL. Similarly, the ITMETH parameter has been removed from the Fortran interface function FCVMALLOC. Instead of specifying the nonlinear iteration type when creating the CVODE(S) memory structure, CVODE(S) uses the SUNNONLINSOL_NEWTON module implementation of a Newton iteration by default.For details on using a non-default or user-supplied nonlinear solver see the “Using CVODE[S] for …” chapters in the user guides. CVODE(S) functions for setting the nonlinear solver options (e.g., CVodeSetMaxNonlinIters) or getting nonlinear solver statistics (e.g., CVodeGetNumNonlinSolvIters) remain unchanged and internally call generic SUNNonlinSol functions as needed.

By default IDA(S) uses the SUNNONLINSOL_NEWTON module. Since IDA(S) previously only used an internal implementation of a Newton iteration no changes are required to user programs and functions for setting the nonlinear solver options (e.g., IDASetMaxNonlinIters) or getting nonlinear solver statistics (e.g., IDAGetNumNonlinSolvIters) remain unchanged and internally call generic SUNNonlinSol functions as needed. While SUNDIALS includes a fixed-point nonlinear solver module, it is not currently supported in IDA(S).For details on using a non-default or user-supplied nonlinear solver see the “Using IDA[S] for …” chapters in the user guides. Additionally, the example program idaRoberts_dns.c explicitly creates an attaches a SUNNONLINSOL_NEWTON object to demonstrate the process of creating and attaching a nonlinear solver module (note this is not necessary in general as IDA uses the SUNNONLINSOL_NEWTON module by default).

Three fused vector operations and seven vector array operations have been added to the NVECTOR API. These optional operations are disabled by default and may be activated by calling vector specific routines after creating an NVECTOR. See the NVECTOR chapter in the user guides for more information on the new operations.

Added a new NVECTOR (NVECTOR_OPENMPDEV) which leverages OpenMP 4.5+ device offloading.

Multiple updates to the CUDA NVECTOR were made:

  • Changed the N_VMake_Cuda function to take a host data pointer and a device data pointer instead of an N_VectorContent_Cuda object.
  • Changed N_VGetLength_Cuda to return the global vector length instead of the local vector length.
  • Added N_VGetLocalLength_Cuda to return the local vector length.
  • Added N_VGetMPIComm_Cuda to return the MPI communicator used.
  • Removed the accessor functions in the namespace suncudavec.  
  • Added the ability to set the cudaStream_t used for execution of the CUDA NVECTOR kernels. See the function N_VSetCudaStreams_Cuda.
  • Added N_VNewManaged_Cuda, N_VMakeManaged_Cuda, and N_VIsManagedMemory_Cuda functions to accommodate using managed memory with the CUDA NVECTOR.

Multiple updates to the RAJA NVECTOR were made:

  • Changed N_VGetLength_Raja to return the global vector length instead of the local vector length.
  • Added N_VGetLocalLength_Raja to return the local vector length.
  • Added N_VGetMPIComm_Raja to return the MPI communicator used.
  • Removed the accessor functions in the namespace sunrajavec.

The SUNBandMatrix constructor has been simplified to remove the storage upper bandwidth argument.

Two changes were made in the CVODE/CVODES/ARKODE initial step size algorithm:

  • Fixed an efficiency bug where an extra call to the RHS function was made.
  • Changed the behavior of the algorithm if the max-iterations case is hit. Before the algorithm would exit with the step size calculated on the penultimate iteration. Now it will exit with the step size calculated on the final iteration.

Fortran 2003 interfaces to CVODE, the fixed-point and Newton nonlinear solvers, the dense, band, KLU, PCG, SPBCGS, SPFGMR, SPGMR, and SPTFQMR linear solvers, and the serial, PThreads, and OpenMP NVECTORs have been added.

The ARKode library has been entirely rewritten to support a modular approach to one-step methods, which should allow for rapid research and development of novel integration methods without affecting existing solver functionality.

A new ARKode stepper, MRIStep, has been added for two rate explicit-explicit multirate infinitesimal step methods.

ARKode’s dense output infrastructure has been improved to support higher-degree Hermite polynomial interpolants (up to degree 5) over the last successful time step.

Changes in patch release SUNDIALS v.3.2.1

  • Fixed a bug in the CUDA NVector where the N_VInvTest operation could write beyond the allocated vector data
  • Fixed library installation path for multiarch systems. This fix changes the default library installation path to CMAKE_INSTALL_PREFIX/CMAKE_INSTALL_LIBDIR from CMAKE_INSTALL_PREFIX/lib. CMAKE_INSTALL_LIBDIR is automatically set, but is available as a CMAKE option that can modified.

Changes in development release SUNDIALS v.4.0.0-dev.2

Version 4.0.0-dev.2 is a third step toward the full 4.0.0 release which should be complete by end of 2018. The 4.0.0 release will include a full redesign of our nonlinear solver interfaces allowing for encapsulation of the nonlinear solvers and ease in interfacing outside nonlinear solver packages, streamlined linear solver interfaces, a restructuring of the ARKode package to allow for more time stepping options, and addition of a two-reate explicit/explicit integrator. 

    • New features and/or enhancements

    ARKode, CVODES, and IDAS have been updated to use the SUNNONLINSOL nonlinear solver API.

    The direct and iterative linear solver interfaces in ARKode, CVODE, IDA, and
    KINSOL have been merged into a single unified linear solver interface to support
    any valid SUNLINSOL module. The unified interface is very similar to the previous
    DLS and SPILS interfaces. To minimize challenges in user migration to the unified
    linear solver interface, the previous DLS and SPILS routines for CVODE, IDA,
    and KINSOL may still be used; these will be deprecated in future releases, so we
    recommend that users migrate to the new names soon. Additionally, we note that
    Fortran users will need to enlarge their iout array of optional integer outputs,
    and update the indices that they query for certain linear-solver-related statistics.

    The names of all constructor routines for SUNDIALS-provided SUNLinSol
    implementations have been updated to follow the naming convention SUNLinSol_*
    where * is the name of the linear solver e.g., Dense, KLU, SPGMR, PCG, etc.
    Solver-specific “set” routine names have been similarly standardized. To
    minimize challenges in user migration to the new names, the previous routine
    names may still be used; these will be deprecated in future releases, so we
    recommend that users migrate to the new names soon.


    The ARKode library has been entirely rewritten to support a modular approach to
    one-step methods, which should allow rapid research and development of novel
    integration methods without affecting existing solver functionality.

    ARKode’s dense output infrastructure has been improved to support higher-degree
    Hermite polynomial interpolants (up to degree 5) over the last successful time step.

    Changes in minor release SUNDIALS v.3.2.0

    • Added hybrid MPI/CUDA and MPI/RAJA vectors to allow use of more than one MPI rank when using a GPU system.  The vectors assume one GPU device per MPI rank.

    • Changed the name of the RAJA NVector library to libsundials\nveccudaraja\lib from libsundials\nvecraja\lib to better reflect that we only support CUDA as a backend for RAJA currently.

    • Increased CMake minimum version to 3.1.3

    • Several changes were made to the build system.

      • If MPI is enabled and MPI compiler wrappers are not set, the build system will check if   CMAKE_<language>_COMPILER can compile MPI programs before trying to locate and use an MPI installation.

      • The native CMake FindMPI module is now used to locate an MPI installation.

      • The options for setting MPI compiler wrappers and the executable for running MPI programs have been updated to align with those in the native CMake FindMPI module. This update included changing MPI_MPICC to MPI_C_COMPILER, MPI_MPICXX to MPI_CXX_COMPILER, combining MPI_MPIF77 and MPI_MPIF90 to MPI_Fortran_COMPILER, and changing MPI_RUN_COMMAND to MPIEXEC.

      • When a Fortran name-mangling scheme is needed (e.g., LAPACK_ENABLE is ON) the build system will infer the scheme from the Fortran compiler. If a Fortran compiler is not available or the inferred or default scheme needs to be overridden, the advanced options SUNDIALS_F77_FUNC_CASE and SUNDIALS_F77_FUNC_UNDERSCORES can be used to manually set the name-mangling scheme and bypass trying to infer the scheme.

      • Additionally, parts of the main CMakeLists.txt file were moved to new files in the src and example directories to make the CMake configuration file structure more modular.

    • In CVODE:

      • Added constraint handling.

    • In CVODES:

      • Fixed a thread-safety issue when using adjoint sensitivity  analysis (thank you to Joris Gillis for informing us of this issue)

      • Added constraint handling.

    • In IDAS:

      • Fixed a thread-safety issue when using adjoint sensitivity  analysis (thank you to Joris Gillis for informing us of this issue)

      • Fixed a bug where the saved residual value used in the nonlinear solve for consistent initial conditions was passed as temporary workspace and could be overwritten.

    Changes in development release SUNDIALS v.4.0.0-dev.1

    Version 4.0.0-dev.1 is a second step toward the full 4.0.0 release which should be complete by end of 2018.  This development release includes all changes for v. 3.1.2.  The 4.0.0 release will include a full redesign of our nonlinear solver interfaces allowing for encapsulation of the nonlinear solvers and ease in interfacing outside nonlinear solver packages as well as a restructuring of the ARKode package to allow for more time stepping options.

    • New features and/or enhancements

    An API for encapsulating the nonlinear solvers used in SUNDIALS implicit
    integrators has been introduced and are utilized by the CVODE and IDA packages.
    The other SUNDIALS packages will be updated to use generic nonlinear solver in a
    later release. The goal of this API is to ease the introduction of new nonlinear
    solver options in SUNDIALS integrators and allow for external or user-supplied
    nonlinear solvers. The SUNNONLINSOL API and provided SUNNONLINSOL modules are
    described in a new user guide chapter and follow the same object oriented design
    and implementation used by the NVECTOR, SUNMATRIX, and SUNLINSOL modules.

    SUNNONLINSOL modules are intended to solve nonlinear systems formulated as
    either a rootfinding problem F(y)=0 or a fixed-point problem y=G(Y).
    Currently two SUNNONLINSOL implementations are provided,
    SUNNONLINSOL_NEWTON and SUNNONLINSOL_FIXEDPOINT. These replicate the
    previous integrator specific implementations of a Newton iteration and a
    fixed-point iteration (previously referred to as functional iteration),
    respectively. Additionally, the fixed-point iteration can use Anderson’s method
    to accelerate convergence. Example programs using each of these nonlinear solver
    modules in a standalone manner have been added and all CVODE AND IDA example programs
    have been updated to use generic SUNNONLINSOL modules.

    With the introduction of SUNNONLINSOL modules in CVODE, the input parameter ITER
    to CVodeCreate has been removed as well as the constants CV_NEWTON
    and CV_FUNCTIONAL. Similarly, the ITMETH parameter has been removed
    from the Fortran interface function FCVMALLOC. Instead of specifying the
    nonlinear iteration type when creating the CVODE memory structure, CVODE
    uses the SUNNONLINSOL_NEWTON module implementation of a Newton iteration by
    default.

    As a result of this new nonlinear solver object creation and attachment approach,
    the function CVodeSetIterType has been removed. CVODE functions for
    setting the nonlinear solver options (e.g., CVodeSetMaxNonlinIters) or
    getting nonlinear solver statistics (e.g., CVodeGetNumNonlinSolvIters)
    remain unchanged and internally call generic SUNNONLINSOL functions.

    In IDA the SUNNONLINSOL_NEWTON module is also the default nonlinear solver
    (and it is the only nonlinear solver enabled for IDA at this time)
    Since IDA previously only used an internal implementation
    of a Newton iteration for nonlinear solves, no changes are required to user
    programs and functions for setting the nonlinear solver options (e.g.,
    IDASetMaxNonlinIters) or getting nonlinear solver statistics (e.g.,
    IDAGetNumNonlinSolvIters) remain unchanged and internally call generic
    SUNNONLINSOL functions.

     

    Changes in minor release SUNDIALS v.3.1.2

     

    • Updated the minimum required version of CMake to 2.8.12 and enabled using rpath by default to locate shared libraries on OSX.
    • Fixed Windows specific problem where ‘sunindextype’ was not correctly defined when using 64-bit integers for the SUNDIALS index type. On Windows ‘sunindextype’ is now defined as the MSVC basic type ‘__int64’

    • Added sparse SUNMatrix “Reallocate” routine to allow specification of the nonzero storage.

    • Updated the KLU SUNLinearSolver module to set constants for the two reinitialization types, and fixed a bug in the full reinitialization approach where the sparse SUNMatrix pointer would go out of scope on some architectures.

    • Updated the “ScaleAdd” and “ScaleAddI” implementations in the sparse SUNMatrix module to more optimally handle the case where the target matrix contained sufficient storage for the sum, but had the wrong sparsity pattern.  The sum now occurs in-place, by performing the sum backwards in the existing storage.  However, it is still more efficient if the user-supplied Jacobian routine allocates storage for the sum ‘I+ gamma J’ manually (with zero entries if needed).

    • Changed the LICENSE install path to ‘instdir/include/sundials’.

    • In CVODE:

      • Added the following examples from the usage notes page of the SUNDIALS website, and updated them to work with SUNDIALS 3.x:

        • ‘cvDisc_dns.c’, which demonstrates using CVODE with discontinuous solutions or RHS.

        • ‘cvRoberts_dns_negsol.c’, which illustrates the use of the RHS function return value to control unphysical negative concentrations.

    • In CVODES:

      • The misnamed function CVSpilsSetJacTimesSetupFnBS in cvodes has been deprecated
        and replaced by CVSpilsSetJacTimesBS. The deprecated function CVSpilsSetJacTimesSetupFnBS
        will be removed in the next major release.

     

    Changes in development release SUNDIALS v.4.0.0-dev

    Version 4.0.0-dev is a first step toward the full 4.0.0 release which should be complete by end of 2018.  The 4.0.0 release will include a full redesign of our nonlinear solver interfaces allowing for encapsulation of the nonlinear solvers and ease in interfacing outside nonlinear solver packages.

    • New features and/or enhancements
      • Three fused vector operations and seven vector array operations have been added to the NVECTOR API. These optional operations are intended to increase data reuse in vector operations, reduce parallel communication on distributed memory systems, and lower the number of kernel launches on systems with accelerators. The new operations are N_VLinearCombination, N_VScaleAddMulti, N_VDotProdMulti, N_VLinearCombinationVectorArray, N_VScaleVectorArray, N_VConstVectorArray, N_VWrmsNormVectorArray, N_VWrmsNormMaskVectorArray, N_VScaleAddMultiVectorArray, and N_VLinearCombinationVectorArray. If any of these operations are defined as NULL in an NVECTOR implementation the NVECTOR interface will automatically call standard NVECTOR operations as necessary.   Details on the new operations can be found in the user guide Chapter on the NVECTOR API.
    • Several changes were made to the build system.
      • If MPI is enabled and MPI compiler wrappers are not set, the build system will check if  CMAKE_<language>_COMPILER can compile MPI programs before trying to locate and use an MPI installation. The native CMake FindMPI module is now used to locate an MPI installation.
      • The options for setting MPI compiler wrappers and the executable for running MPI programs have been updated to align with those in the native CMake FindMPI module. This included changing MPI_MPICC to MPI_C_COMPILER, MPI_MPICXX to MPI_CXX_COMPILER, combining MPI_MPIF77 and MPI_MPIF90 to MPI_Fortran_COMPILER, and changing MPI_RUN_COMMAND to MPIEXEC.
      • When a Fortran name-mangling scheme is needed (e.g., LAPACK_ENABLE is ON) the build system will infer the scheme from the Fortran compiler. If a Fortran compiler is not available or the inferred or default scheme needs to be overridden, the advanced options SUNDIALS_F77_FUNC_CASE and SUNDIALS_F77_FUNC_UNDERSCORES can be used to manually set the name-mangling scheme and bypass trying to infer the scheme.
      • Parts of the main CMakeLists.txt file were moved to new files in the src and example directories to make the CMake configuration file structure more modular.

    Changes in minor release SUNDIALS v.3.1.1

    • Fixed a potential memory leak in the SPGMR and SPFGMR linear solvers: if “Initialize” was called multiple times then the solver memory was reallocated (without being freed).
    • Fixed C++11 compiler errors/warnings about incompatible use of string literals.

    • Updated KLU SUNLinearSolver module to use a typedef for the precision-specific solve function to be used (to avoid compiler warnings).

    • Added missing typecasts for some (void*) pointers (again, to avoid compiler warnings).

    • Bugfix in sunmatrix_sparse.c where we had used ‘int’ instead of ‘sunindextype’ in one location.

    • Added missing #include <stdio.h> in NVECTOR and SUNMATRIX header files.

    • Fixed an indexing bug in the CUDA NVECTOR implementation of N_VWrmsNormMask and revised the RAJA NVECTOR implementation of N_VWrmsNormMask to work with mask arrays using values other than zero or one. Replaced doubles with realtypes in the RAJA vector test functions.

    • Fixed compilation issue with GCC 7.3.0 and Fortran programs that do not require a SUNMatrix or SUNLinearSolver module (e.g. iterative linear solvers, explicit methods in ARKode, functional iteration in CVODE, etc.).

    • In ARKode:

      • Fixed a minor bug in the ARKReInit routine, where a flag was incorrectly set to indicate that the problem had been resized (instead of just re-initialized).

      • Added missing prototype for ARKSpilsGetNumMTSetups.

    • In IDA and IDAS

      • Added missing prototypes for IDASpilsGetNumJTSetupEvals in IDA and IDAS.

    • In CVODE and CVODES:

      • Fixed a minor bug in the CVODE and CVODES cvSLdet routine, where a return was missing in the error check for three inconsistent roots.
    • In KINSOL:
      • Fixed a minor bug in KINPrintInfo where a case was missing for KIN_REPTD_SYSFUNC_ERR leading to an undefined info message.

     

    Changes in major release SUNDIALS v.3.1.0

     

    • New features and/or enhancements
      • Added NVECTOR print functions that write vector data to a specified file (e.g., N_VPrintFile_Serial).
      • Added ‘make test’ and ‘make test_install’ options to the build system for testing SUNDIALS after building with ‘make’ and installing with ‘make install’ respectively.
      • Added “Changes in …” (latest version) to Intro. in all User Guides.

    Changes in major release SUNDIALS v.3.0.0

    • New features and/or enhancements
      • New linear solver API and interfaces for all SUNDIALS packages and linear solvers.  The goal of the redesign of these interfaces was to provide more encapsulation and ease in interfacing custom linear solvers and interoperability with linear solver libraries.
        • Added generic SUNMATRIX module with three provided implementations: dense, banded, and sparse.  These implementations replicate previous SUNDIALS Dls and Sls matrix structures in a single object-oriented API.
        • Added example problems demonstrating use of generic SUNMATRIX modules.
        • Added generic SUNLINEARSOLVER module with eleven provided implementations: dense, banded, LAPACK dense, LAPACK band, KLU, SuperLU_MT, SPGMR, SPBCGS, SPTFQMR, SPFGMR, and PCG.  These implementations replicate previous SUNDIALS generic linear solvers in a single object-oriented API.
        • Added example problems demonstrating use of generic SUNLINEARSOLVER modules.
        • Expanded package-provided direct linear solver (Dls) interfaces and scaled, preconditioned, iterative linear solver (Spils) interfaces to utilize generic SUNMATRIX and SUNLINEARSOLVER objects.
        • Removed package-specific, linear solver-specific, solver modules (e.g. CVDENSE, KINBAND, IDAKLU, ARKSPGMR) since their functionality is entirely replicated by the generic Dls/Spils interfaces and SUNLINEARSOLVER/SUNMATRIX modules.  The exception is CVDIAG, a diagonal approximate Jacobian solver available to CVODE and CVODES.
        • Converted all SUNDIALS example problems to utilize new generic SUNMATRIX and SUNLINEARSOLVER objects, along with updated Dls and Spils linear solver interfaces.
        • Added Spils interface routines to ARKode, CVODE, CVODES, IDA and IDAS to allow specification of a user-provided “JTSetup” routine. This change supports users who wish to set up data structures for the user-provided Jacobian-times-vector (“JTimes”) routine, and where the cost of one JTSetup setup per Newton iteration can be amortized between multiple JTimes calls.
      • Two new NVECTOR modules added: for CUDA and RAJA support for GPU systems.  These vectors are supplied to provide very basic support for running on GPU architectures.  Users are advised that these vectors both move all data to the GPU device upon construction, and speedup will only be realized if the user also conducts the right-hand-side function evaluation on the device. In addition, these vectors assume the problem fits on one GPU. For further information about RAJA, users are referred to the web site, https://software.llnl.gov/RAJA/.
      • Addition of sunindextype option for 32- or 64-bit integer data index types within all SUNDIALS structures.
        • Sunindextype can be int64_t or int32_t or long long int and int depending on machine support for portable types.
        • The Fortran interfaces continue to use long_int for indices, except for their sparse matrix interface that now uses the new sunindextype.
        • Includes interfaces to PETSc, hypre, SuperLU_MT, and KLU with either 64-bit or 32-bit capabilities depending how the user configures SUNDIALS.
      • Temporary vectors were removed from preconditioner setup and solve routines for all packages.  It is assumed that all necessary data for user-provided preconditioner operations will be allocated and stored in user-provided data structures.
      • The file include/sundials_fconfig.h was added.  This file contains SUNDIALS type information for use in Fortran programs. 
      • Added support for many xSDK-compliant build system keys.
        • The xSDK is a movement in scientific software to provide a foundation for the rapid and efficient production of high-quality, sustainable extreme-scale scientific applications. 
        • More information can be found at https://xsdk.info.
      • Added functions SUNDIALSGetVersion and SUNDIALSGetVersionNumber to
        get SUNDIALS release version information at runtime.

      • To avoid potential namespace conflicts, the macros defining booleantype values TRUE and FALSE have been changed to SUNTRUE and SUNFALSE respectively.

      • In build system:

        • Added separate BLAS_ENABLE and BLAS_LIBRARIES CMake variables.
        • Additional error checking during CMake configuration.
        • Fixed minor CMake bugs.
        • Renamed CMake options to enable/disable examples for greater clarity and added option to enable/disable Fortran 77 examples:
          • Changed EXAMPLES_ENABLE to EXAMPLES_ENABLE_C.
          • Changed CXX_ENABLE to EXAMPLES_ENABLE_CXX.
          • Changed F90_ENABLE to EXAMPLES_ENABLE_F90.
          • Added EXAMPLES_ENABLE_F77 option.
      • Corrections and additions to all User Guides.
    • In ARKode:
      • Added comments to arkode_butcher.c regarding which methods should have coefficients accurate enough for use in quad precision.
      • Bug Fix: Fixed a bug in arkode_butcher.c in use of RCONST.
      • Bug Fix: Fixed a bug in the arkInitialSetup utility routine in the order of operations when setting up and using mass matrices to ensure the mass matrix vector product is set up before the “msetup”
          routine is called.
      • Fixed ARKode printf-related compiler warnings when building SUNDIALS with extended precision.
    • In CVODE/CVODES:
      • In CVodeFree, now call lfree() unconditionally (if non-NULL).
    • In IDA/IDAS:
      • Bug Fix: Added missing prototype for IDASetMaxBacksIC in ida.h and idas.h.
    • In KINSOL:
      • Bug Fix: Corrected KINSOL fcmix name translation for FKIN_SPFGMR.

    Changes in major release SUNDIALS v.2.7.0

    • Two new NVECTOR modules added: for Hypre ParVector and PETSC.
    • In vector API, added new required function, N_VGetVectorID.
    • Upgrades to sparse solver interfaces; now support CSR matrix type with KLU solver.
    • In all packages, example codes were changed from using NV_DATA macro to using N_VGetArrayPointer_* when using the native vectors shipped with SUNDIALS
    • In all packages, fixed memory leak in banded preconditioner interface.
    • Fixed some examples w.r.t. switch to new macro/function names SUNRexp etc.
    • Various minor fixes to installation-related files.
    • Corrected name N_VCloneEmptyVectorArray to N_VCloneVectorArrayEmpty in all documentation files.
    • Updated all packages to return integers from linear solver and preconditioner ‘free’ functions.
    • Removed Matlab interface from distribution as it has not been updated since 2009.  We expect to update this interface soon.
    • In FKINSOL, FCVODE, and FIDA, added missing Fortran interface routines so that users can supply the sparse Jacobian routine.
    • Minor corrections and additions to all User Guides, including removal of references to specific NVECTOR names in usage skeletons.
    • Additional example programs added throughout.
    • In CVODE
      • in FCVODE, fixed argument order bugs in FCVKLU and FCVSUPERLUMT linear solver interfaces.
    • In CVODES
      • changed each **FreeB() to type int; added return(0) to each.  
      • in interpolation routines for backward problems, added logic to bypass sensitivity interpolation if input sensitivity argument is NULL.
    • In ARKODE
      • updated linear and mass matrix solvers so that ‘free’ routines return integer instead of void; updated documentation accordingly.
      • fixed initialization of linear solver performance counters.
      • method and embedding for Billington and TRBDF2 explicit Runge-Kutta methods were swapped.
      • fix for user specification of absolute tolerance array along with vector Resize() functionality.
      • fix for user-supplied Butcher tables without embeddings (if fixed time steps or manual adaptivity are employed).
      • multiple documentation updates.
      • added missing ARKSpilsGetNumMtimesEvals() function. 
      • implicit predictor algorithms were updated: methods 2 and 3 were improved, a new predictor approach was added, and the default choice was modified.
      • revised handling of integer codes for specifying built-in Butcher tables: a global numbering system is still used, but methods now have #defined names to simplify the user interface.
      • maximum number of Butcher table stages was increased from 8 to 15 to accommodate very high order methods, and an 8th-order adaptive ERK method was added.
      • added support for the explicit and implicit methods in an additive Runge-Kutta method to utilize different stage times, solution and embedding coefficients, to support new SSP-ARK methods.
      • extended FARKODE interface to include a routine to set scalar/array-valued residual tolerances, to support Fortran applications with non-identity mass-matrices.
    • In IDA
      • corrected example idaFoodWeb_bnd.c in PrintOutput (wrong component printed).
      • added optional input function IDASetMaxBacksIC to limit number of linesearch backtrack operations in IDACalcIC.  User guides amended accordingly.
    • In IDAS
      • added optional input function IDASetMaxBacksIC to limit number of linesearch backtrack operations in IDACalcIC.  User guides amended accordingly.
      • changed each **FreeB() to type int; added return(0) to each.  
      • in interpolation routines for backward problems, added logic to bypass sensitivity interpolation if input sensitivity argument is NULL.
    • In KINSOL
      • minor bug fix in Picard iteration.
      • minor bug fix in line search to prevent infinite loop when beta condition fails and lambda is below minimum size.

    Changes in minor release SUNDIALS v.2.6.2

    • In IDAS, added missing backward problem support functions: IDALapackDenseB, IDALapackDenseFreeB, IDALapackBandB, IDALapackBandFreeB
    • In KINSOL and ARKode, updated Anderson acceleration implementation with QR updating.
    • Updated BiCGStab solver to remove redundant dot product call.
    • Minor corrections and additions to all User Guides.
    • In CVODES and IDAS header files, corrected documentation of backward integration functions, especially the ‘which’ argument.
    • In CVODES, added DVKLUB prototype and corrected CVSuperLUMTB prototype.
    • In IDAS, made SuperLUMT call for backward problem consistent with CVODES.
    • In CVODES and IDAS, added ReInit and SetOrdering wrappers for backward problems. Fixed potential memory leak in KLU ReInit functions in all solvers.
    • In CVODE, IDA, and ARKode, fixed Fortran interfaces to enable calls to *GetErrWeights, *GetEstLocalErrors, and *GetDky within a time step. In ARKode, fixed a bug in one Butcher table.
    • In ARKode, fixed error in arkDoErrorTest in recovery after failure.
    • In IDAS, fixed for-loop bugs in IDAAckpntAllocVectors Various minor fixes to installation-related files.

    Summary of changes in minor release SUNDIALS v.2.6.1

    • Fixed loop limit bug in SlsAddMat function.
    • In all six solver interfaces to KLU and SuperLUMT, added #include lines, and removed redundant KLU structure allocations.
    • Numerous minor documentation improvements
    • Minor bug fixes in ARKode

    Summary of major changes in SUNDIALS v.2.6.0

    • Addition of ARKode package of explicit, implicit, and additive Runge-Kutta methods for ODES. This package API is close to CVODE so switching between the two should be straightforward. Thanks go to Daniel Reynolds for the addition of this package.
    • Addition of support for two sparse direct solver packages when using the serial vector structure, KLU and SuperLU_MT. exploits highly sparse systems. SuperLU_MT supports multithreading in the factorization.
    • Addition of openMP and PThreads vector kernels.
    • Addition of fixed point and Picard iterative solvers within KINSOL. These are both optionally accelerated with Anderson acceleration.
    • Addition of FGMRES support for KINSOL.
    • Removal of autotools configuration support. We now exclusively use CMake.
    • Numerous bug fixes throughout.

      Summary of major changes in v2.5.0?

      • Changes to user interface
        • Problem size and related integers (bandwidth parameters etc.) all have type long int, except in BLAS and LAPACK routines. Function NewIntArray is replaced by a pair NewIntArray/NewLintArray, for int and long int arrays, respectively.

        Summary of major changes in v2.4.0?

        • New features
          • new linear solver module, based on Blas and Lapack for both dense and banded matrices.
        • Changes to user interface
          • reorganization of all linear solver modules into two families (besides the existing family of scaled preconditioned iterative linear solvers, the direct solvers, including the new Lapack-based ones, were also organized into a direct family).
        • Changes related to the build system
          • provide CMake-based build option, in addition to that based on autotools.

          Summary of major changes in v2.3.0?

          • Changes to the user interface
            • modified the functions in the generic dense linear solver (sundials_dense and sundials_smalldense) to work for rectangular m by n matrices (m ≤ n).
            • renamed the factorization and solution functions in the generic dense linear solver to DenseGETRF/denGETRF and DenseGETRS/denGETRS, respectively.
            • renamed the factorization and solution functions in the generic band linear solver to BandGBTRF and BandGBTRS, respectively.
          • Changes related to the build system
            • rearranged the entire SUNDIALS source tree
            • all exported header files are now installed in separate subdirectories of the installation include directory
            • header files are included now by specifying the relative path (e.g. #include <sundials/sundials_types.h>)

            Summary of major changes in v2.2.0?

            • New features
              • added SPBCG (scaled preconditioned Bi-CGStab) linear solver module
              • added SPTFQMR (scaled preconditioned TFQMR) linear solver module
            • Changes related to the build system
              • updated configure script and Makefiles for Fortran examples to avoid C++ compiler errors (now use CC and MPICC to link only if necessary)
              • SUNDIALS shared header files are installed under a sundials subdirectory of the installation include directory
              • the shared object files are now linked into each SUNDIALS library rather than into a separate libsundials_shared library
            • Changes to the user interface
              • added prefix sundials_ to all shared header files

              Summary of major changes in v2.1.1?

              • Changes to the generic NVECTOR module
                • N_VCloneEmpty was added to the global vector operations table

              Summary of major changes in v2.0.2?

              • Changes related to the build system
                • fixed autoconf-related bug to allow configuration with the PGI Fortran compiler
                • modified to use customized detection of the Fortran name mangling scheme (autoconf’s AC_F77_WRAPPERS routine is problematic on some platforms)

                Summary of major changes in v2.0.1?

                • Changes related to the build system
                  • changed order of compiler directives in header files to avoid compilation errors when using a C++ compiler.
                  • changed method of generating sundials_config.h to avoid potential warnings of redefinition of preprocessor symbols.

                  Summary of major changes in v2.0?

                  • Changes to the generic NVECTOR module
                    • removed machEnv, redefined table of vector operations (now contained in the N_Vector structure itself).
                    • all SUNDIALS functions create new N_Vector variables through cloning, using an N_Vector passed by the user as a template.
                    • a particular NVECTOR implementation is supposed to provide user-callable constructor and destructor functions.
                    • removed from structure of vector operations the following functions: N_VNew, N_VNew_S, N_VFree, N_VFree_S, N_VMake, N_VDispose, N_VGetData, N_VSetData, N_VConstrProdPos, and N_VOneMask.
                    • added in structure of vector operations the following functions: N_VClone, N_VDestroy, N_VSpace, N_VGetArrayPointer, N_VSetArrayPointer, and N_VWrmsNormMask.
                    • Note that nvec_ser and nvec_par are now separate modules outside the shared SUNDIALS module.
                  • Changes to the generic linear solvers
                    • in SPGMR, added a dummy N_Vector argument to be used as a template for cloning.
                    • in SPGMR, removed N (problem dimension) from argument list of SpgmrMalloc.
                    • iterative.{c,h} replace iterativ.{c,h}
                    • modified constant names in iterative.h (preconditioner types are prefixed with ‘PREC_’).
                    • changed numerical values for MODIFIED_GS (from 0 to 1) and CLASSICAL_GS (from 1 to 2).
                  • Changes to sundialsmath submodule
                    • replaced internal routine for estimation of unit roundoff with definition of unit roundoff from float.h
                    • modified functions to call appropriate math routines given the precision level specified by the user.
                  • Changes to sundialstypes submodule
                    • removed type ‘integertype’.
                    • added definitions for ‘BIG_REAL’, ‘SMALL_REAL’, and ‘UNIT_ROUNDOFF’ using values from float.h based on the precision.
                    • changed definition of macro RCONST to depend on precision.

                  cvode release history

                   

                  cvodes release history

                   

                  arkode release history

                   

                  ida release history

                   

                  idas release history

                   

                  kinsol release history


                  TOP :: CVODE :: CVODES :: ARKODE ::  IDA :: IDAS
                  KINSOL :: sundialsTB

                  sundialsTB

                  sundialsTB is no longer distributed as of sundials v. 2.7.0 as it has not been updated in many years.

                  What’s new in v2.5.0?

                  • Bug fixes
                    • fixed lines setting etachoice in kimOpts.c
                    • in cvm.c and idm.c, fixed size of rootsfound array; added lines to free rootsfound and ckpnt arrays when done using each
                  • What’s new in v2.4.0?
                  • New Features
                    • the Matlab interface to IDAS was extended to provide sensitivity analysis capabilities.
                  • Changes to user interface
                    • the API for adjoint sensitivity analysis (cvodes and idas) was modified to support simultaneous integration of multiple backward problems.

                  What’s new in v2.3.0?

                  • New features
                    • added Matlab interface to IDA (named idas)
                    • on platforms which support configure scripts, installation of sundialsTB can now be enabled while configuring SUNDIALS and installed through make and make install (provided a working MEX compiler is found).
                  • Bug fixes
                    • the installation script install_STB.m was modified to increase robustness on various platforms (related to path and file names).
                  • Changes to user interface
                    • (cvodes) for improved legibility, some of the keys for forward sensitivity optional inputs were renamed.
                    • (cvodes) removed xaxis type option for the internal monitoring function CVodeMonitor.

                  What’s new in v2.2.0?

                  • New features
                    • modified installation procedure to use a Matlab script
                    • added sample Matlab startup file
                    • (cvodes) expanded CVodeMonitor
                    • (kinsol) added interface to KINSOL’s performance monitoring function (‘Verbose’ option to KINSetOptions)
                  • Bug fixes
                    • (cvodes) fixed bug in interface to quadrature integration which was causing a segmentation violation when monitoring was turned on.
                  • Changes to user interface
                    • updated to reflect changes to the SUNDIALS libraries in v.2.2.0
                    • (cvodes) changed the interface for sensitivity analysis (both forward and adjoint) to follow more closely the CVODES calling sequence
                    • (cvodes) optional inputs for forward sensitivity analysis are now provided through a separate function, CVodeSensSetOptions
                    • removed NVM mex interface