DAE Tools Project Files

                DAE Tools v1.8.1 (22 August 2018)

Supported platforms: GNU/Linux (x86_64), macOS (x86_64) and Windows (x86 and x64).

Binaries provided for GNU/Linux, macOS and Windows (python 2.7, 3.4, 3.5, 3.6 and 3.7). 

Linux binaries compiled with:
 - g++ 6.3 (libc 2.24)
 - g++ 4.9 (libc 2.19)
Windows binaries compiled with msvc++ 2015.
macOS binaries compiled with g++ 6.3 and XCode 7.3.1.

All platforms use PyQt5.

                                Installation

All platforms (GNU/Linux, macOS, Windows):

  Unpack the archive and run (may require sudo): 
  python setup.py install

Release info:
    The new version brings the support for the Open Compute Stack (OpenCS) framework
    and fully working iterative linear solvers (Sundials and Trilinos AztecOO GMRES).
                       
                                 Changelog
                            
- Open Compute Stack (OpenCS) framework:
   - Libraries:
      - OpenCS_Models
      - OpenCS_Evaluators
      - OpenCS_Simulators
   - Concepts:
      - Compute Stack (header-only C99: a postfix notation expression stack)
      - Compute Stack Machine (header-only C99: a stack machine for evaluation of a single equation)
      - Compute Stack Evaluator (C++: an interface for parallel evaluation of systems of equations)
      - Compute Stack Model (C++: model specification data structures)
      - Compute Stack Differential Equations Model (C++: an interface providing API for ODE/DAE solvers)
      - Compute Stack Simulator (csSimulator_ODE and csSimulator_DAE generic seqential/parallel simulators 
                                 based on the Compute Stack interface)
      - Model Builder: a class for creation of ODE/DAE Compute Stack models, including the
                       partitioning algorithm (re-implemented in C++) and export of input files with 
                       the model specification for sequential/parallel ODE/DAE simulations: 
		 - model_structure-[pe].bin: model variables data
		 - model_equations-[pe].bin: compute stacks and active equation set indexes
		 - sparsity_pattern-[pe].bin: the sparsity pattern (for evaluation of derivatives)
		 - partition_data-[pe].bin: inter-process communication data
		 - solver_options.json: simulation, model, ODE/DAE and linear solver options
        All input files contain a header with two int32_t items: fileType and OpenCS version
   - Examples:
      - ODE problems:
         1. The Roberts chemical kinetics problem with 3 rate equations (cvsRoberts_dns example from CVodes)
         2. Simple advection-diffusion in 2D (cvsAdvDiff_bnd example from CVodes)
         3. 2-species diurnal kinetics advection-diffusion PDE system in 2D (cvsDiurnal_kry example from CVodes)
      - DAE problems:
         1. The chemical kinetics problem with 6 non-linear diff. equations (idasAkzoNob_dns example from IDAS)
         2. A simple heat conduction problem in 2D (tutorial1 from DAE Tools)
         3. A chemically reacting system known as Brusselator PDE (idasBruss_kry_bbd_p example from IDAS)
  CMake-based compilation.
  All daetools modules now use the functionality from OpenCS (compute_stack.h is removed, OpenCS/cs_machine.h is used now). 
  Evaluator_OpenCL library removed (not required anymore) while pyEvaluator_OpenCL links to libOpenCS_Evaluators.
- Changes in the MPI code generator
  - Fixed bugs:
    - Vertex weights were in a wrong format (should be flat vweights[Nvariables, Ncnstraints] array)
    - The argument recursive is set to True
  - It generates input files for compute stack simulators:
    In addition, it produces:
     - sparsity_pattern-pe.png
     - partition_graph.png
     - partition_stats.tex and partition_stats.csv (statistcs of the partition results)
   The Partition algorithm (using METIS) performs edge-cut minimisation and takes into account 
   four additional balancing constrains:
   - Ncs: number of Compute Stack items
   - Nflops: number of FLOPS for evaluation of residuals
   - Nnz: number of non-zero items in the incidence matrix
   - Nflops_j: number of FLOPS for evaluation of the Jacobian matrix

Simulation statistics:
- Added detailed statistics and timings/counts for:
  - Simulation (Initialization, SolveInitial, Integrate)
  - DAE solver (LASetup, LASolve, Residuals, Jacobian, SensitivityResiduals, Roots, 
    PreconditionerSetup, PreconditionerSolve, JacobianVectorMultiply)
  - NL solver (N iterations, error test fails)
  - LA solver (Create, Reinitialize, Setup, Solve, Jacobian)
  - Preconditioner (Create, Reinitialize, Setup, Solve, Jacobian, JacobianVectorMultiply)
- Added new function daeSimulation::PrintStats
- Added namespace call_stats with two classes TimeAndCount and TimerCounter.
  They are used to count the number of calls and the duration of specified
  functions or blocks of code.
- Added new function GetCallStats to daeSimulation_t, daeBlock_t, daeDAESolver_t,
  daeLASolver_t, daePrecondiitoner_t and adComputeStackEvaluator_t classes that returns
  a dictionary with the calls stats: std::map<std::string, call_stats::TimeAndCount>.
- GetTimeInSeconds now uses OpenMP function omp_get_wtime 
  (the old could not measure time in functions that use OpenMP functions)

Linear solver and preconditioners:
- daeIDASolver.SetLASolver now accepts the solver type and the preconditioner 
  (if Sundials gmres is used)
- New classes: 
   - daePreconditioner_t abstract base class for Sundials gmres preconditioners
   - daePreconditioner_Ifpack
   - daePreconditioner_ML 
- daetools.cfg: 
   - New section daetools.IDAS.gmres with the options for Sundials gmres linear solver
   - New option daetools.activity.printStats
- Removed daeIDALASolver_t abstract class (not required anymore).
  All functions modified to use daeLASolver_t abstract class.
- Trilinos solvers have only one attribute ParameterList 
  (separate lists for individual solvers/preconditioners are removed).
  Only ML complains about options from AztecOO solver; can be suppressed 
  by setting "ML validate parameter list" parameter to false.
- All solvers/preconditioners have functions for getting/setting solver options.
  daeLASolver_t and daePreconditioner_t abstract classes now have functions:
   GetOption_string, GetOption_bool, GetOption_int, GetOption_float,
   SetOption_string, SetOption_bool, SetOption_int, SetOption_float.
  Currently they only work in Trilinos solvers and preconditioners.
- Fixed bugs in Trilinnos_AztecOO solver (preconditioner re-compute after change in Jacobian matrix).
  Known issues:
   - Somewhat lower performance of AztecOO with native preconditioners
     (preconditioner is first destroyed and then regenerated)
- Linear solvers do not depend on IDA library and all functions (such as la_init, ..., la_free)
  moved to daeIDASolver. Changed the interface of daeIDALASolver_t (everything is in the base class).

Changes in the core detools functionality (for OpenCS support):
- New functions:
   - adNode::EstimateComputeStackFlops, adNode::GetNodeCount and adNode::SizeOf
   - daeEquationExecutionInfo::GetComputeStackInfo, daeEquationExecutionInfo::GetDiffVariableIndexes
   - daeBlock::ExportComputeStackStructs, daeBlock::GetActiveEquationSetMemory, 
     daeBlock::GetActiveEquationSetNodeCount, daeBlock::ExportComputeStackStructs
   - daeSimulation::ExportComputeStackStructs
- New classes:
   - daeBlockOfEquations_t for decoupling the DAE solver from daetools