**DAE Tools** is a cross-platform equation-based object-oriented modelling, simulation
and optimisation software. It is not a modelling language nor a collection of numerical
libraries but rather a higher level structure – an architectural design of interdependent
software components providing an API for:

- Model development/specification
- Activities on developed models, such as simulation, sensitivity analysis, optimisation and parameter estimation
- Processing of the results, such as plotting and exporting to various file formats
- Report generation
- Code generation, co-simulation and model exchange

The following class of problems can be solved by **DAE Tools**:

- Initial value problems of implicit form, described by a system of linear, non-linear, and (partial-)differential algebraic equations
- Index-1 DAE systems
- With lumped or distributed parameters: Finite Difference, Finite Volume or Finite Elements Methods
- Steady-state or dynamic
- Continuous with some elements of event-driven systems (discontinuous equations, state transition networks and discrete events)

Type of activities that can be performed on models developed in **DAE Tools**:

- Simulation (steady-state or dynamic, with simple or complex schedules)
- Sensitivity analysis (local or global methods)
- Optimisation (NLP and MINLP problems)
- Parameter estimation
- Generation of model reports (in XML + MathML/LaTex format with XSL transformations for XHTML code generation)
- Code generation for other modelling or general-purpose programming languages
- Modelica
- gPROMS
- Standard ISO C (c99)
- C++/MPI

- Simulation in other simulators using standard co-simulation interfaces
- Export of the simulation results to various file formats:
- Matlab MAT (.mat)
- Microsoft Excel (.xls)
- Comma Separated Values (.csv)
- JSON (.json)
- XML (.xml)
- Hierarchical Data Format (.hdf5)
- Pandas (Python Data Analysis) data sets
- VTK (.vtk)

**DAE Tools** run on all major operating systems (Windows, GNU Linux and Mac OS X)
and architectures (x86, x86_64, arm).

It is free to use, since it is free software and released under the GNU General Public Licence.

**DAE Tools** is initially developed to model and simulate processes in chemical process industry
(mass, heat and momentum transfers, chemical reactions, separation processes, thermodynamics).
However, **DAE Tools** can be used to develop high-accuracy models of (in general) many different
kind of processes/phenomena, simulate/optimise them, visualise and analyse the results.

The following approaches/paradigms are adopted in **DAE Tools**:

- A hybrid approach between general-purpose programming languages (such as c++ and Python) and domain-specific modelling languages (such as Modelica, gPROMS, Ascend etc.) (more information: The Hybrid approach).
- An object-oriented approach to process modelling (more information: The Object-Oriented approach).
- An Equation-Oriented (acausal) approach where all model variables and equations are generated and gathered together and solved simultaneously using a suitable mathematical algorithm (more information: The Equation-Oriented approach).
- Separation of the model definition from the activities that can be carried out on that model. The structure of the model (parameters, variables, equations, state transition networks etc.) is given in the model class while the runtime information in the simulation class. This way, based on a single model definition, one or more different simulation/optimisation scenarios can be defined.
- Core libraries are written in standard c++, however Python is used as the main modelling language (more information: Programming language).

All core libraries are written in standard c++. It is highly portable - it runs on all
major operating systems (GNU/Linux, MacOS, Windows) and all platforms with a decent c++ compiler,
Boost and standard c/c++ libraries (by now it is tested on 32/64 bit x86 and ARM architectures
making it suitable for use in embedded systems). Models can be developed in Python
(**pyDAE** module) or c++ (**cDAE** module), compiled into an independent
executable and deployed without a need for any run time libraries.

Parallel computation is supported using the shared-memory parallel programming model at the moment. The following part of the code support parallelisation:

- Evaluation of equations, Jacobian matrix and sensitivity residuals using OpenMP API or OpenCL framework
- Assembly of Finite Element systems using OpenMP API
- Solution of systems of linear equations (SuperLU_MT, Pardiso and Intel Pardiso solvers)

In addition, there is an experimental code generator that generates C++ source code with the support for MPI interface.

**DAE Tools** support a large number of solvers. Currently Sundials IDAS
solver is used to solve DAE systems and calculate sensitivities, while BONMIN,
IPOPT, and NLOPT
solvers are used to solve NLP/MINLP problems.
**DAE Tools** support direct dense and sparse matrix linear solvers (sequential and multi-threaded versions)
at the moment. In addition to the built-in Sundials linear solvers, several third party libraries are interfaced:
SuperLU/SuperLU_MT,
Pardiso,
Intel Pardiso,
Trilinos Amesos (KLU, Umfpack, SuperLU, Lapack),
and Trilinos AztecOO (with built-in, Ifpack or ML preconditioners)
which can take advantage of multi-core/cpu computers.

The quality of the software is a very important aspect and the formal code verification techniques are applied to test almost all aspects of the software. Several tests using the most rigorous methods (such as the Method of Exact Solutions and the Method of Manufactured Solutions) and the most rigorous acceptance criteria (such as the order-of-accuracy) have been developed and successfully passed.

**DAE Tools** is free software and you can redistribute it and/or modify it under the terms of
the GNU General Public Licence version 3 as published by
the Free Software Foundation (GNU philosophy).

- If you use DAE Tools in your work then please cite the following article:
- Nikolić DD. (2016)
*DAE Tools: equation-based object-oriented modelling, simulation and optimisation software*.**PeerJ Computer Science**2:e54 https://doi.org/10.7717/peerj-cs.54.

BibTeX: daetools-peerj.bib.

**“Necessity, who is the mother of invention”***Plato, Greek author & philosopher (427 BC - 347 BC), The Republic***“Every good work of software starts by scratching a developer’s personal itch”***Eric S. Raymond, hacker, The Cathedral and the Bazaar, 1997*

The latter cannot be more true [1]. The early ideas of starting a project like this go back into 2007. At that time I have been working on my PhD thesis using one of commercially available process modelling software. It was everything nice and well until I discovered some annoying bugs and lack of certain highly appreciated features. The developers of that proprietary program (as it is a case with all proprietary computer programs) had their own agenda fixing only what they wanted to fix and introducing new features that they anticipated. Although I was able to improve the code and introduce certain features which will help (not only) me - I was helpless. The source code was not available and nobody will ever consider giving it to me to create patches with bugs fixes/new features. Not even if I swear on the holy (c++) bible!!

Very soon the contours of a new process modelling software slowly began to form. It took me a while until I made a definite plan and initial features, and I had to abandon a couple of initial versions...

**“Plan to throw one away; you will, anyhow”***Eric S. Raymond, hacker, The Cathedral and the Bazaar, 1997*

Damn you Eric Raymond, interfering with my business again! :-) The new project was officially born early next year - 2008.

[1] | However, I do not agree with Eric Raymond and the Open Source Iniative views - they miss the point IMO, but let us leave it beside at the moment. |

DAE Tools use the following third party free software libraries (GNU GPL, GNU LGPL, CPL, EPL, BSD or some other type of free/permissive/copy-left licences):

- Sundials IDAS: https://computation.llnl.gov/casc/sundials/main.html
- Boost: http://www.boost.org
- ADOL-C: https://projects.coin-or.org/ADOL-C
- Numpy: http://numpy.scipy.orghttp://numpy.scipy.org
- Scipy: http://www.scipy.org
- Blas/Lapack/CLapack: http://www.netlib.org
- Minpack: http://www.netlib.org/minpack
- Trilinos Amesos: http://trilinos.sandia.gov/packages/amesos
- Trilinos AztecOO: http://trilinos.sandia.gov/packages/aztecoo
- SuperLU/SuperLU_MT: http://crd.lbl.gov/~xiaoye/SuperLU/index.html
- Umfpack: http://www.cise.ufl.edu/research/sparse/umfpack
- MUMPS: http://graal.ens-lyon.fr/MUMPS
- IPOPT: https://projects.coin-or.org/Ipopt
- Bonmin: https://projects.coin-or.org/Bonmin
- NLOPT: http://ab-initio.mit.edu/wiki/index.php/NLopt
- pyQt: http://www.riverbankcomputing.co.uk/software/pyqt
- Matplotlib: http://matplotlib.sourceforge.net
- SALib: https://github.com/SALib/SALib
- lxml: http://lxml.de
- openpyxl: http://www.python-excel.org
- HDF5 for Python: http://www.h5py.org
- Pandas: http://pandas.pydata.org
- Mayavi2: http://docs.enthought.com/mayavi/mayavi
- PyGraphviz: https://pygraphviz.github.io
- PyEVTK: https://pypi.python.org/pypi/PyEVTK

**DAE Tools** can optionally use the following proprietary software libraries:

- Pardiso linear solver (pyPardiso module): http://www.pardiso-project.org
- Intel Pardiso linear solver (pyIntelPardiso module): http://software.intel.com/en-us/articles/intel-mkl
- OpenCL drivers/runtime libraries (Intel: https://software.intel.com/en-us/articles/opencl-drivers; AMD: https://support.amd.com/en-us/kb-articles/Pages/OpenCL2-Driver.aspx; NVidia: https://developer.nvidia.com/opencl)

Please see the corresponding websites for more details about the licences.