DAE Tools Changelog

What's new in DAE Tools 1.9.0

Apr 2, 2019

Dimensionless quantity objects now use a global dimensionless unit object.
This saves a lot of memory (500 MB out of 2-3GB in some cases).
Finite Element models clear the unused memory saving a lot of memory.
AdNode classes can optionally use boost memory pools for allocation of setup and runtime nodes.
The most often used node types (in particular for FE models) are:
Constants, Unary and Binary operators/functions and FloatCoefficientVariableSum.
This is controlled in daetools.cfg:
nodes.useNodeMemoryPools: if true switches on pool usage
nodes.deleteNodesThreshold: the number of equations when the setup and runtime nodes
deallocated and the memory freed
Added python wrappers (pyOpenCS) for OpenCS. The following classes are supported:
Abstract csLog_t, csDataReporter_t and csGraphPartitioner_t classes and their
StdOut/TextFile, CSV/HDF5 and Simple/Metis/2D_Npde implementations
csNumber_t, csModel_t and csModelBuilder_t classes
csSimulate functions
Added a replacement for daeCodeGenerator_MPI - daeCodeGenerator_OpenCS which uses
pyOpenCS python module and a new csNode_wrapper class to handle daetools equations
without duplicating the memory for csNodes. It supports all daetools features except:
Discontinuous equations (STNs and IFs)
External functions
Thermo-physical property packages
Compute Stack Machine for evaluation of equation uses the evaluate funcion that
works on the plain real_t (not adouble_t) avoiding caculation of derivatives
when they are not required.
Re-implemented ODE 1-3 and DAE 1-3 examples in python and added a new section to
DAE Tools tutorials: OpenCS Examples.
New data reporter: daePickleDataReporter which saves the results as the Python pickle
file which can be opened in DAE Plotter or unpickled directly from Python.
Added new integration mode: OneStep, new function daeSimulation.IntegrateForOneStep and
new options in daetools.cfg to control the integration mode:
integrationMode - "Normal" or "OneStep"
reportDataInOneStepMode - if true and integrationMode is OneStep the data will be
reported after every time step (not only at the specified reporting intervals).
Updated tutorial 7 to introduce the new IntegrateForOneStep function.

New in DAE Tools 1.8.1 (Aug 23, 2018)

Open Compute Stack (OpenCS) framework:
Libraries:
OpenCS_Models
OpenCS_Evaluators
OpenCS_Simulators
Concepts (general):
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)
Concepts (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
Concepts (examples):
ODE problems:
The Roberts chemical kinetics problem with 3 rate equations (cvsRoberts_dns example from CVodes)
Simple advection-diffusion in 2D (cvsAdvDiff_bnd example from CVodes)
2-species diurnal kinetics advection-diffusion PDE system in 2D (cvsDiurnal_kry example from CVodes)
DAE problems:
The chemical kinetics problem with 6 non-linear diff. equations (idasAkzoNob_dns example from IDAS)
A simple heat conduction problem in 2D (tutorial1 from DAE Tools)
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.
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

New in DAE Tools 1.8.0 (Mar 20, 2018)

New in DAE Tools 1.7.3 (Oct 25, 2017)

New in DAE Tools 1.7.2 (Aug 30, 2017)

New features:
New class daeActivity with two static functions: simulate and optimize. Updated all tutorials with the new, simpler way of executing simulations.
Fixed FMI code generator, SimulationLoader and FMU_CS libraries:
FMU_CS library does not link cdaeConfig shared library anymore
Fixed resources['simulationFile'] value in fmi.py (it should be only the filename not the full path).
In Windows python/Lib and Python/DLLs directories are programmatically added to the PATH/PYTHONPATH (in the SimulationLoader library).
In GNU/Linux Python/lib directory needs to be manually added to the LD_LIBRARY_PATH (only for custom python installations and virtual environments; system python installations do not need this)
In GNU/Linux python shared library needs to be loaded using dlopen (despite it was already loaded by FMI_CS library). Otherwise the code does not work: for instance, numpy cowardly refuses to import.
Variables from the top-level model can be exported as 'local' or 'output' FMI variables.
Added function create_simulation_for_cosimulation to pyDAE/__init__.py that can be used as a default simulation instantiation/initialisation function in daetools_mex, daetools_s and daetools_fmi_cs. It accepts simulation class name and some optional arguments (i.e. relativeTolerance).
Additional files argument of the daeCodeGenerator_FMI.generateSimulation function is now a list of tuples: [('file_path', 'resources_dir_relative_path'), ...] i.e. in tutorial_dealii_1: [(mesh_file, 'meshes/step-49.msh')]
Added a new optional argument to the daeCodeGenerator_FMI.generateSimulation function: localsAsOutputs = False. If it is true, variables from the top-level model are added as output FMI variables; otherwise, they are added as local FMI variables.
Function daeModel::GetCoSimulationInterface now has a new argument std::vector<daeVariable_t*> ptrarrModelVariables filled with the variables from the top-level model (treated as locals in FMI).
Function daeModel::GetFMIInterface now also adds variables from the top-level model to the std::map<size_t, daeFMI2Object_t> map as FMI 'Local' variables.
Function daeSimulationLoader::GetFMIValue now also returns values for 'Local' FMI variables.
Fixed bug in getFolderFromURI function (handling of file:/// in Windows).
Added a new function: daeSimulationLoader::SetRelativeTolerance. It is used in the fmi2SetupExperiment function to handle the tolerance argument (if toleranceDefined argument is true).
Updated generate_fmus.py file. It generates the FMU files for selected tutorials and generates all files required for the FMI ComplianceChecker (i.e. scripts to run .fmu files with the ComplianceChecker, the reference solution from the exporting tool, the .opt options and ReadMe.txt files).
daetools.cfg config file is now properly located on all platforms.
New daeSimulation properties: StopAtModelDiscontinuity and ReportDataAroundDiscontinuities and new boolean options stopAtModelDiscontinuity and reportDataAroundDiscontinuities in daetools.activity section n daetools.cfg. The properties control the default behaviour of daeSimulation.Run function. If StopAtModelDiscontinuity=true the simulation will stop at every discontinuty. If ReportDataAroundDiscontinuities=true the data will be reported before and after the discontinuity.
Added a new daeCSVFileDataReporter (saves the results into a .csv file).
OpenMP assembly refactored into the OpenMP_WorkStream::run function.
Added OpenMP shared library (vcomp.dll) to the setup.py in Windows.
Fixed bug in daeVariable::GetType function.

New in DAE Tools 1.7.1 (Aug 18, 2017)

New features:
Added a new section: Code Verification Tests (The Method of Exact Solutions and Method of Manufactured Solutions). The section contains 10 tests.
Added a new section: Sensitivity Analysis Examples.Sensitivity analysis can be performed using the local methods (derivative-based, using sensitivities calculated by IDAS solver) or global methods available in SALib python library: Elementary Effect (Morris) and Variance-based (FAST, Sobol).
The global Sensitivity Analysis methods (tutorial_sa_3.py) can use python multiprocessing module to calculate the outputs in parallel (i.e. using a pool of workers and the Pool.map function).
Implemented high-resolution cell-centered upwind scheme with flux limiter (daeHRUpwindScheme).
Equation residuals/Jacobian/sensitivity residuals can be evaluated in parallel using the OpenMP. Number of OpenMP threads (and other options) can be specified in the daetools.cfg file (section "daetools.core.equations").
Equations have a new boolean property: SimplifyExpressions. The default value (false) is specified in daetools.cfg file ("daetools.core.equations.simplifyExpressions").
eQuasySteadyState renamed to eQuasiSteadyState. eQuasiSteadyState initial condition mode applied to the simulation in the tutorial7.py
Finite Element systems can be assembled in parallel. There are three options: Sequential, OpenMP and TBB (deal.II WorkStream) which can be specified in the daetools.cfg file (section "daetools.deal_II.assembly"). Multithreded TBB is available only in GNU/Linux.
Expressions in deal.II mass/stiffness matrices and load vector are much simpler now by skipping addition of contributions that always evaluate to zero (tests performed by hasNonzeroValue() function).
Finite Element equations and surface/volume integrals expressions are simplified by default.
Significantly improved the adNode::SimplifyNode function.
dealiiFiniteElementDof<dim> constructor now also accepts the variable type (the default is no_t).
setFEInitialConditions function also accepts a callable with two arguments: variableIndex, overallIndex.
Two new deal.ii tutorials: 2D transient Stokes flow driven by the differences in buoyancy (tutorial_dealii_7.py) and a small parallel-plate reactor with an active surface (tutorial_dealii_8.py).
Updated dof_approximation, dof_gradient_approximation, vector_dof_approximation, vector_dof_gradient_approximation and dof_gradient_approximation functions. As the result, the created expressions are much simpler and require less memory and time to evaluate.
New FE functions: symmetric_gradient<dim>, feExpression<dim>::scalar_product and feExpression<dim>::double_contract.
Added pickling/unpickling of daeDataReceiverProcess and related objects. Now the simulation data in the DAE Plotter can be saved/loaded from a file.
Fixed zoom problems in 2D plots.
Added a new type of 2D plots: variable 1 vs. variable 2.
Animated 2D plot can show more than one curve.
New property daeIDAS.IntegratorStats returns a dictionary with the stats from the solver.
A new class: daeNodeGaph that generates graphs based on equation expressions. The generated graphs can be saved as images.
Updated documentation: sensitivity analysis, numerical methods for PDE, logging, DAE solvers, LA solvers, optimisation, data reporting. deal.ii tutorials now show animated gifs with the results.
Fixed issue with minpack solver
New functions in dealiiFiniteElementSystem<dim>:
ClearAssembledData (clears the arrays/matrices allocated during the assembly phase)
GetBoundaryDOFs (returns a list of boolean flags indicating whether the specified DOF is on one of the given boundaries)
GetDOFSupportPoints (returns a list of Point<dim>objects for all DOFs, if there are supports points in the FiniteElement object)
WeakForm now accepts contributions as either a single feExpression<dim> object or as the python list objects. The items in the list can be individual feExpression<dim> objects a tuple of feExpression<dim> objects (q_loop, i_loop, j_loop). Splitting of weak form expressions results in simpler expressions and a faster execution.

New in DAE Tools 1.7.0 (Jun 5, 2017)

New features:
Updated User Guide with new sections (user-defines actions, external functions, simulation explorer, executing simulations/optimisations and performing sensitivity analysis).
Updated tutorials.
MacOS version is again available (only for 64 bit x86 architecture). XCode's clang does not work since openmp is not available. gcc 6.3 from HPC for Mac is used. -rpath issue resolved (using @rpath/... in shared libs and @loader_path/../../solibs/Darwin_x86_64/... in python extension modules).
Support for thermophysical property packages (tutorial 19).
Sensitivity matrices can be obtained using the daesolver.SensitivityMatrix property and saved to .mmx files in the user-specified directory using the simulation.SensitivityDataDirectory property (tutorial 20).
Sensitivity data can be reported using the simulation.ReportSensitivities boolean property. For instance, in this case the sensitivity of the variable with the canonical name "m1.m2.variable" per sensitivity parameter "p1" is reported as "m1.m2.sensitivities.d(variable)/d(p1)".
Two sensitivity analysis benchmarks are added:
tutorial21.py where the usage of DAESolver.SensitivityMatrix is illustrated and where numerical sensitivities are compared to analytical ones for the constant coefficient first order differential equations.
tutorial_che_9.py where numerical sensitivities are compared to the literature data for the Dow Chemicals Company reaction network problem described in Caracotsios and Stewart (1985).
Time derivatives can be reported using the simulation.ReportTimeDerivatives boolean property. Here, the time derivative of the variable with the canonical name "m1.m2.variable" is reported as "m1.m2.time_derivatives.d(variable)/dt".
Variables have BlockIndexes ndarray properties with the block indexes for all points in the variable. If the variable is not distributed on domains then the BlockIndexes returns an integer.
Functions __call__, array, dt_array, d_array and d2_array in daeParameter and daeVariable can use -1 as an argument. Similar to python/numpy arrays, -1 selects the last point from the corresponding domain.
Operators __bool__ and __nonzero__ added to adouble and adouble_array classes. They raise not-implemented exceptions preventing inadvertent calls to Python's built-in operators not, and, or.
Standard mathematical functions also added to adouble_array class.
The script install_python_dependencies.sh updated to enable python versions.
Fixed daetools.cfg detection using boost::filesystem::canonical() function.

New in DAE Tools 1.7.0 Beta 2 (May 16, 2017)

New in DAE Tools 1.7.0 Beta 1 (May 5, 2017)

New in DAE Tools 1.6.1 (Apr 21, 2017)

New in DAE Tools 1.4.0 (Jan 15, 2015)

Code generators for Modelica, gPROMS and c99. They can be found in daetools/code_generators. Almost all features available in daetools are supported except event ports, user defined actions, external functions and finite element objects whose equations need to be updated during a simulation.
Support for simulation in other simulators using standard interfaces for Co-Simulation: Functional Mockup Interface (FMI), Matlab MEX-functions and Simulink S-functions.
Added SimulationLoader project with c and c++ interface that can load a simulation from a python file and perform all other available operations on it. It is used by daetools_mex (Matlab MEX wrapper), daetools_s (Simulink S-function wrapper) and daetools_fmi_cs (FMI for Co-Simulation wrapper).
DAE Tools objects such as adouble can be used as NumPy native data type. The most of the NumPy and SciPy functions are supported.
New data reporters that export the simulation results to various file formats (MS Excel, hdf5, xml, json) and to Pandas data sets.
Added new math functions: Sinh, Cosh, Tanh, ASinh, ACosh, ATanh, ATan2, Erf and Erf to adouble/adouble_array.
Added Pardiso linear solver.
Added SimulationExplorer GUI that lists all domains, parameters, initial conditions, degrees of freedom and state transition networks.
Simulations can export the initialization values to JSON format (daeSimulationExplorer.generateJSONSettings, daeSimulationExplorer.saveJSOnSettings) and initialize using a JSON string (auxiliary.InitializeSimulation function). daeSimulation.Initialize accepts an optional argument jsonRuntimeSettings. daetools.cfg config file is now in JSON format.
Condition nodes can be exported to Latex.
All node classes have NodeAsPlainText and NodeAsLatex functions.
Added new function dictVariableValues that returns a tuple (values:ndarray, times:ndarray, domains:list).
Domains and parameters can now be propagated through the whole model hierarchy (daeModel.PropagateDomain() and daeModel.PropagateParameter()). All domains/parameters with the same name will have identical properties.
daeVariable functions SetValues, SetInitialConditions, AssignValues etc. accept NumPy arrays as arguments. Now, values and initial conditions can be set using numpy float or quantity arrays.
Runtime model reports show completely expanded equations now. Consequently, many adRuntimeNode-classes are deleted.
Functions that operate on adouble_array objects always generate setup nodes and never perform any calculations
All data reporters have ConnectString and ProcessName attributes.
Fixed bug in unit class (one day has 83400 seconds).
All equation can generate Jacobian expressions by setting daeEquation.BuildJacobianExpressions to True. This is useful when an expression is huge and contains a large number of variables. Calculation of a Jacobian for such equation would take a very long time. Generation of Jacobian expressions will increase the memory requirements but may tremendously decrease the computational time. They are stored in daeEquationExecutionInfo.JacobianExpressions and the equation execution infos are stored in daeEquation.EquationExecutionInfos.
daeConfig first looks for config files in /etc/daetools and then in HOME/.daetools directory. If it can’t find any config file it remains empty and consequently the defaults are used.
Added operator ~ (logical NOT) to adouble class.
Fixed bug in unit::toString function.
Other small improvements and minor bugs fixes

New in DAE Tools 1.3.0 Beta 3 (Jan 15, 2015)

Fixed bug in 3D plot
Functions Sum, Product, Average, Min, Max, d, dt moved to the global namespace
adouble_array objects can be manipulated from python now. Two new static functions are added to adouble_array: FromList and FromNumpyArray which take as an argument a list/ndarray of double objects and return adouble_array. Several new functions were added: __len__, __getitem__, __setitem__, items
Functions GetNumpyArray from daeVariable, daeParameter and daeDomain replaced with npyValues attribute.
Added new function to daeVariable: GetDomainsIndexesMap
Added new attributes to daeVariable: npyIDs, npyValues, npyTimeDerivatives
operator() in daeDomain does the same as operator[]
Equations have EquationType attribute
daeModel has GetModelType function that returns one of: eSteadyState, eDynamic, eODE
Added operators +=, -+, *= and /+ to adouble
Added new constructors to adouble and adouble_array
All python wrapper classes have updated __str__ and __repr__ functions
New documentation in Sphinx
Removed daeStateTransition class from pyCore Added a new class daeOnConditionActions
Changed ON_CONDITION function and now accepts a list of tuples (STN_Name, State_Name). This way an unlimited number of active states can be set
Added some unit tests
Folders daePlotter and daeSimulator renamed to dae_plotter and dae_simulator Many other files renamed to lower case names
Fixed bug with nested STNs and IFs
Updated daetools.xslt and daetools-rt.xslt files
Added LastSatisfiedCondition to daeSimulation class that returns the condition that caused a discontinuity
daeDataReporterProcess renamed to daeDataReceiverProcess. Added new attributes: dictDomains and dictVariables to enable access to the results through dictionary like interface. The same attributes added to daeDataReporterLocal
Implemented daeTCPIPLog and daeTCPIPLogServer
Added daeDelegateLog with the same functionality as daeDelegateDataReporter
Added new tutorials and optimization tutorials
Fixed bugs in SaveAsMathML functions for some nodes
Added function array to daeDomain
Fixed bug in units for constraints and objective function. Now they have the same units as their residual function
New functions in daeOptimization: StartIterationRun and EndIterationRun
Added a new argument ‘name’ to daeEquation.DistributeOnDomain function. Now distribution domains can have a user-defined names
Options for IDA solver can be set through daetools.cfg config file
Fixed bug in the eQuasySteadyState initialization mode in daeSimulation
Function DeclareEquations must be called from derived-classes’ DeclareEquations function
Unit consistency test can be switched on or off for individual equations through CheckUnitConsistency attribute in daeEquation class
Added functions to daeIDAS DAE solver: OnCalculateResiduals, OnCalculateJacobian, OnCalculateConditions, OnCalculateSensitivityResiduals, and new attributes: Values, TimeDerivatives, Residuals, Jacobian, SensitivityResiduals
Fixed but in initialization of the DAE system where discontinuities were not properly handled
Fixed bug in daeSimulation.Reinitialize function where the root functions were not being updated
Fixed bug with taking the variables’ indexes from quations located in STN or IF blocks, causing the Jacobian matrix to be invalid in certain cases
Fixed bug in daeExternalFunction_t related to processing of adouble_array type of arguments
Added new node class: adSetupCustomNodeArray and new static functions to adouble_array: FromNumpyArray and FromList that create adouble_array object from the given list/ndarray of adoubles with setup nodes. Useful when using daetools array functions on arrays of adoubles that are a product of numpy operations.
Implemented daeVectorExternalFunction
Added EstLocalErrors and ErrWeights functions to daeIDAS dae solver
IDAS solver now takes abs. tolerances from the daetools.cfg config file
Fixed memory leaks with smart pointers (in boost::intrusive_ptr)
Fixed but with the reset of DAE solver during optimization
Now before every optimization iteration the initialization file is loaded
Added daeFiniteElementModel and daeFiniteElementEquation classes
Added pyDealII FE solver
Added daeSimulationExplorer
Other small improvements and minor bugs fixes

New in DAE Tools 1.2.1 (Sep 27, 2013)

New in DAE Tools 1.1.2 (Sep 30, 2011)

daeObjectiveFunction, daeOptimizationVariable, and daeOptimizationConstraint classes have two new attributes (Value and Gradients). daeSimulation::Initialize function accepts an additional argument bCalculateGradients (default is false) which instructs simulation object to calculate gradients of the objective function and optimization variables specified in daeSimulation::SetUpSensitivityAnalysis overloaded function. These changes allow much easier coupling of daetools with some external software (as given in optimization tutorials 4 and 5).
New type of ports: event ports (daeEventPort class). Event ports allow sending of messages (events) between two units (models). Events can be triggered manually or as a result of a state transition in a model. The main difference between event and ordinary ports is that the former allow a discrete communication between units while latter allow a continuous exchange of information. A single outlet event port can be connected to unlimited number of inlet event ports. Messages contain a floating point value that can be used by a recipient; that value might be a simple number or an expression involving model variables/parameters.
A new function ON_EVENT in the daeModel class that specifies how the incoming events on a specific event port are handled (that is the actions to be undertaken when the event is received; class: daeAction). ON_EVENT handlers can be specified in models and in states so that the actions executed when the event is trigerred can differ subject to the current active state. Four different types of actions can be specified:
Change the active state in the specified state transition network
Trigger an event on the specified outlet event port
Reassign or reinitialize a value of the specified variable
Execute the user-defined action (users should derive a new class from daeAction and overload the function Execute)
A new way of handling state transitions: the function ON_CONDITION in daeModel that specifies actions to be undertaken when the logical condition is satisfied. The same types of actions as in the function ON_EVENT are supported. The old function SWITCH_TO is still supported but the new one should be used for it is much flexible.
Non-linear least square minimization with daeMinpackLeastSq (scipy wrapper of Levenberg-Marquardt algorithm from Minpack)
Examples of DAE Tools and Scipy interoperabilty (scipy.optimize.fmin, scipy.optimize.leastsq)
Fixed sensitivity calculation in steady-state models. There was no bug in the previous versions, but if the objective function or constraint did not explicitly depend on some of the optimization variables the calculated sensitivity for these variables was zero.
Developed shell scripts to compile third party libraries (Sundials IDAS, SuperLU/SuperLU_MT, Trilinos, Bonmin, and NLopt), DAE Tools core libraries and boost.python extension modules (compile_libraries_linux.sh, compile_linux.sh).
The new function time in daeModel class; it returns adouble object with the current time elapsed in the simulation that can be used in define equations' residuals.
The new property 'ReportingTimes' in daeSimulation class that returns time points when data should be reported.
Fixed bug in daePlotter when there was a variable and a port with the same name within the model. Now a port and a variable can have the same name.
Some of the tutorials are available in c++ (cDAE) too.
Because of the way how the standard c++ library handles the std::vector' internal memory storage the memory requiremens could possibly grow rather high for large models. That is fixed now and vectors will not demand more memory than required for elements storage; that is achieved by explicitly allocating memory for all elements and comes with some penalties (small speed loss during the creation of the system, approximately 1%; however, the system creation time is very low and there is no overall performance degradation).
Some API polishing

New in DAE Tools 1.1.1 (Jun 25, 2011)

The main focus was to find and adapt a free multithreaded sparse direct solver for use with DAE Tools and it turned out that the best candidate is SuperLU_MT. As of DAE Tools v1.1.1 SuperLU (singlethreaded) and SuperLU_MT (multithreaded) are recommended linear equation solvers. All the other (Trilinos group of solvers, Intel Pardiso, ...) will remain there but with less support.
A set of Krylov iterative solvers has been added. Trilinos AztecOO solver with IFPACK, ML or built-in preconditioners is available. However, iterative solvers are not fully working yet and these solvers are still in an early/experimental phase.
As the GPGPUs become more and more attractive an effort is made to try to offload computation of the most demanding tasks to GPU. The starting point is obviously a linear equation solver and two options are offered:
CUSP
SuperLU_CUDA (OpenMP version of SuperLU_MT modifed to work on CUDA GPU devices). The solver is still in the early development phase and the brief description is given in SuperLU_CUDA. Few issues still remain unsolved and a help from CUDA experienced developers is welcomed!
The new NLP solver has been added (NLOPT from the Massachusetts Institute of Technology). More information about NLOPT and available solvers can be found on NLOPT wiki pages.
To separate NLP from MINLP problems the IPOPT is now a standalone solver.
All linear solvers are located in daetools/solvers directory.
Now all linear solvers support exporting sparse/dense matrices in .xpm image and matrix market file formats.
Models and ports now can be exported into some other modelling language. At the moment, models can be exported into pyDAE (python) and cDAE (c++) but other languages will be supported in the future (such as OpenModelica, EMSO, perhaps some proprietary etc...).
New data reporter (daeMatlabMATDataReporter) has been added that allows user to export the result into the Matlab MAT file format.
Operators + and - for daeDistributedEquationDomainInfo (daeDEDI) class which enable getting values/derivatives in distributed equations that are not equal to the index of the current iterator (see distillation column example for usage).
daeParameter/daeVariable constructors accept a list of domains (analogous to calling DistributeOnDomain for each domain).
Now all constraints are specified in the following way:
Inequality constraints: g(i)