DAE Tools Project Files

                            DAE Tools v1.6.0 (1 March 2017)

Supported platforms: GNU/Linux (i686, x86_64), Windows (32 bit) and MacOS (x86, x86_64). 
Binaries provided for python 2.7, 3.4 (Windows and GNU/Linux) and 3.5 (GNU/Linux only). 
For the other platforms, architectures and python versions daetools must be compiled from the source. 

                            Installation 

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

  Unpack the archive and run: 
  sudo python setup.py install

                            Changelog

- Updated documentation.

- daeSimulation.SetContinuousOptimizationVariable also accepts quantity arguments (not only plain floats).  
  daeDomain.CreateStructuredGrid also accepts quantity arguments (not only plain floats).  

- IPOPT solver has the scaling parameters.

- daeFunctionWithGradients and daeOptimizationVariable have scaling parameters (the defaults is 1.0).

- DAESolver now has the SetTimeHorizon function to prevent  the solver to integrate past 
  the specified time horizon (internally it uses SetStopTime).

- Config files under Windows are now located properly.
  Created a new shared library daeConfig-pyMM. Now, the config is shared among modules 
  (before, every module had its own instance of it) and changes will be reflected on all modules.
  Config files have the global daeSetConfigFile(configFilePath) function to set user-specified daetools.cfg file.

- Updated support for optimisation problems and optimisation solvers.

- A new Chemical Engineering Optimisation Examples section has been added with 5 COPS optimisation, 
  optimal control and parameter estimation tests.

- Updated the global functions d(), d2() and dt(). 
  Now they accept all types of expressions/functions from math.h (except min, max, erf, floor, and ceil).

- Old tutorials split into 4 sections:

  - Basic
  - Advanced
  - Finite Element
  - Optimisation

  and a new section Chemical Engineering Examples is added to the documentation.

  It contains the following models:

  - CSTR
  - Plug Flow Reactor
  - Binary distillation column
  - Batch crystalliser
  - Discretised Population Balance equations solved using high-resoluton upwind scheme with flux limiter (2x)
  - Li-ion battery (porous electrode theory by J.Newman and coworkers)
  - Porous membrane model employing Generalised Maxwell-Stefan equations

  Tutorials 16, 18, 20 and 23 are moved to the advanced section and became tutorial_adv_1,2,3,4.

  Tutorial 19 is now 16, and tutorial 21 is now 18.

  The deal.II tutorials now include:

  - Transient heat conduction
  - Transient heat convection
  - Cahn-Hilliard equation
  - Flow through the porous media
  - Steady-state diffusion and first-order reaction in an irregular catalyst shape

  All tutorials has been updated with the more detailed descriptions, equations and plots of the results.

  Updated sphinx documentation with the new theme (bootstrap, bootswatch_theme: readable) and its options.

- Windows port updates:

  - No installers are provided anymore. The installation process is the same for all platforms: python setup.py install
  - Added daeplotter.bat and daeexamples.bat files so the DAE Plotter and DAEExamples can be started from the command line.
  - Only win32 architecture left (win64 were causing errors when using 32 bit daetools on 64 bit Windows). Changes made to setup.py and daetools/__init__.py

- A major revision of the support for Finite Elements (through deal.II library)

  - Multi-scalar FE systems work well now. Vector systems need to be tested (still not ready).
  - Weak form expressions can contain adouble objects that is the expressions with daeVariable and daeParameter objects.
    Consequently, the non-linear finite elements are automatically supported.
  - The weak form now consists of the following contributions:

    a) Aij - cell contribution to the system stiffness matrix.
    b) Mij - cell contribution to the mass stiffness matrix.
    c) Fi  - cell contribution to the load vector.
    d) boundaryFaceAij  - boundary face contribution to the system stiffness matrix.
    e) boundaryFaceFi   - boundary face contribution to the load vector
    f) innerCellFaceAij - inner cell face contribution to the system stiffness matrix.
    g) innerCellFaceFi  - inner cell face contribution to the load vector
    h) functionsDirichletBC - Dirichlet boundary conditions
    i) surfaceIntegrals - surface integrals
    j) volumeIntegrals  - volume  integrals

  - The list of functions for building weak form expressions:

    - phi (variableName, shapeFunction, quadraturePoint): corresponds to shape_value in deal.II
    - dphi (variableName, shapeFunction, quadraturePoint): corresponds to shape_grad in deal.II
    - d2phi (variableName, shapeFunction, quadraturePoint): corresponds to shape_hessian in deal.II
    - phi_vector (variableName, shapeFunction, quadraturePoint): corresponds to shape_value of vector dofs in deal.II
    - dphi_vector (variableName, shapeFunction, quadraturePoint): corresponds to shape_grad of vector dofs in deal.II
    - d2phi_vector (variableName, shapeFunction, quadraturePoint): corresponds to shape_hessian of vector dofs in deal.II
    - div_phi (variableName, shapeFunction, quadraturePoint): corresponds to divergence in deal.II
    - JxW (quadraturePoint): corresponds to the mapped quadrature weight in deal.II
    - xyz (quadraturePoint): returns the point for the specified quadrature point in deal.II
    - normal (quadraturePoint): corresponds to the normal_vector in deal.II
    - function_value (functionName, function, point, component): wraps Function<dim> object that returns a value
    - function_gradient (functionName, function, point, component): wraps Function<dim> object that returns a gradient
    - function_adouble_value (functionName, function, point, component): wraps Function<dim> object that returns adouble value
    - function_adouble_gradient (functionName, function, point, component): wraps Function<dim> object that returns adouble gradient
    - dof (variableName, shapeFunction): returns daetools variable at the given index (adouble object)
    - dof_approximation (variableName, shapeFunction): returns FE approximation of a quantity as a daetools variable (adouble object)
    - dof_gradient_approximation (variableName, shapeFunction): returns FE gradient approximation of a quantity as a daetools variable (adouble object)
    - dof_hessian_approximation (variableName, shapeFunction): returns FE hessian approximation of a quantity as a daetools variable (adouble object)
    - vector_dof_approximation (variableName, shapeFunction): returns FE approximation of a vector quantity as a daetools variable (adouble object)
    - vector_dof_gradient_approximation (variableName, shapeFunction): returns FE approximation of a vector quantity as a daetools variable (adouble object)
    - adouble (ad): wraps any daetools expression to be used in matrix assembly
    - tensor1 (t): wraps deal.II Tensor<rank=1>
    - tensor2 (t): wraps deal.II Tensor<rank=2>
    - tensor2 (t): wraps deal.II Tensor<rank=3>

  - Supported almost all FiniteElement classes from deal.II:

    - FE_Q, FE_Bernstein
    - FE_ABF, FE_BDM, FE_Nedelec, FE_RaviartThomas
    - FE_DGP, FE_DGQ, FE_DGBDM, FE_DGNedelec, FE_DGRaviartThomas

  - Supported almost all quadrature rules: QGauss, QGaussLobatto, QMidpoint, QSimpson, QTrapez, QMilne, QWeddle, QGaussLog, QGaussLogR,
    QGaussOneOverR, QGaussChebyshev, QGaussLobattoChebyshev
  - Added support for surface/volume integrals over boundaries.
  - Initial conditions are now set using the function setFEInitialConditions().
  
- New VTK data reporter (daeVTKDataReporter).

- The macro CLONE_NODE, the copy constructor and operator = do not deep copy adNode-derived objects anymore but just take the source node smart pointer.
  The memory used is lower now.
  
- Added a new boolean option daetools.core.checkForInfiniteNumbers to daetools.cfg and a function to the daeDataProxy class CheckForInfiniteNumbers().
  This options can be used while calculating residuals, Jacobian and sensitivity residuals to check if a value/derivative is a finite number (that is not +inf, -inf, nan).
  By the default it is disabled (for performance reasons).
  
- Added try/catch statements in Residual/Jacobian/SensitivityResiduals calculation to be able to track equations which are the source of errors.
  Exceptions are re-thrown so the simulation will still fail but this time with the name of the equation and the reason of the failure.
  Useful when sqrt or logarithm functions are called for negative basis, for instance.
  
- Added diagnostics in adNode-derived runtime classes that checks values for nan, -inf, +inf

- DAE solver now also reports data after a failure in SolveInitial() and Reinitalize() functions.

- adSetupVariableNode and adRuntimeVariableNode objects are stored in std::map<overall_index,node*> to reduce the memory requirements.

- Modified model reports .xslt and .css files.

- Fixed bug with the propagation of the global execution context. It has been propagated only from the current level model downwards.
  Now, it is always propagated from the top level model.

- Small bug fix in unit::toLatex() function.

- Fixed bug in quantity::operator /(double, adouble).

- Fixed small bug when saving 2D plot templates (domainIndexes are reset by the ChooseVariable dialog) causing the empty list in the json template.

- Equations and EquationExecutionInfos are not exported into MathML but Latex instead. The file size of the runtime reports is shrank from tens of mb to 100 kb.
  MathJax used to render Latex into html+css.

- Equations now do not save the residual node in xml (Expression tag) since it was not used anywhere and required huge files.

- Greek html symbols (i.e. &lambda;) are converted into the Latex (i.e. \lambda).

- Other small updates/fixes.