This document contains the release notes for JModelica.org 1.3.0.

Highlights:
  - Functional Mockup Interface (FMI) simulation support
  - Support for minimum time problems
  - Improved support for redecare/replaceable in the compiler frontend
  - Limited support for external functions
  - Support for stream connections (with up to two connectors in a connection)

1. Compilers

1.1. Modelica Compiler

1.1.1 Arrays

Slice operations are now supported.
 
Array support is now nearly complete. The exceptions are:
 * Functions with array inputs with sizes declared as ':' - only basic support.
 * A few array-related function-like operators are not supported.
 * Connect clauses does not handle arrays of connectors properly.

1.1.2 Redeclare

Redeclares as class elements are now supported.

1.1.3 Conditional components

Conditional components are now supported.

1.1.4 Constants and parameters

Function calls can now be used as binding expressions for parameters 
and constants. The handling of Integer, Boolean and record type parameters 
is also improved.

1.1.5 External functions

 * Basic support for external functions written in C. 
 * Annotations for libraries, includes, library directories and include 
   directories supported.
 * Platform directories supported.
 * Can not be used together with CppAD. 
 * Arrays as arguments are not yet supported. Functions in Modelica_utilies 
   are also not supported.

1.1.6 Stream connectors

Stream connectors, including the operators inStream and actualStream
and connections with up to two stream connectors are supported.

1.1.7 Miscellaneous

The error checking has been improved, eliminating many erroneous error
messages for correct Modelica code.

The memory and time usage for the compiler has been greatly reduced for 
medium and large models, especially for complex class structures.

1.2. Optimica Compiler

All support mentioned for the Modelica compiler applies to the
Optimica compiler as well.

1.2.1 New class attribute objectiveIntegrand

Support for the objectiveIntegrand class attribute. In order to
encode Lagrange cost functions of the type

\int_{t_0}^{t_f}L(.)dt,

the Optimica class attribute objectiveIntegrand is supported by the
Optimica compiler. The expression L may be utilized by optimization
algorithms providing dedicated support for Lagrange cost functions.

1.2.2 Support for minimum time problems. 

Optimization problems with free initial and terminal times can now be
solved by setting the free attribute of the class attributes startTime
and finalTime to true. The Optimica compiler automatically translates
the problem into a fixed horizon problems with free parameters for the
start en terminal times, which in turn are used to rescale the time of
the problem.

Using this method, no changes are required to the optimization
algorithm, since a fixed horizon problem is solved.

2. JModelica.org Model Interface (JMI)

2.2 The collocation optimization algorithm

2.2.1 Dependent parameters

Support for free dependent parameters in the collocation
optimization algorithm is now implemented. In models containing parameter declarations
such as

parameter Real p1(free=true);
parameter Real p2 = p1;

where the parameter p2 needs to be considered as being free in the
optimization problem, with the additional equality constraint

p2 = p1

included in the problem. 

2.2.2 Support for Lagrange cost functions. 

The new Optimica class attribute objectiveIntegrand, see above, is
supported by the collocation optimization algorithm. The integral cost
is approximated by a Radau quadrature formula.

3. Assimulo

Support for simulation of an FMU (see below) using Assimulo. Simulation
of an FMU can either be done by using the high-level method *simulate* or
creating a model from the FMIModel class together with a problem class,
FMIODE which is then passed to CVode.

4. FMI compliance

Improved support for the Functional Mockup Interface (FMI) standard.
Support for importing an FMI model, FMU (Functional Mockup Unit). The 
import consist of loading the FMU into Python and connecting the models
C execution interface to Python. Note, strings are not currently supported.

Imported FMUs can be simulated using the Assimulo package.

5. XML model export

5.1 noEvent operator

Support for the built-in operator noEvent has been implemented.

5.2 static attribute

Support for the Optimica attribute static has been implemented. 

6. Python integration

6.1 High-level functions

6.1.1 Model files

Passing more than one model file to high-level functions supported.

6.1.2 New result object

A result object is used as return argument for all algorithms. The 
result object for each algorithm extends the base class ResultBase and 
will therefore (at least) contain: the model object, the result file name, 
the solver used and the result data object.

6.2 File I/O

Rewriting xmlparser.py has improved performance when writing 
simulation result data to file considerably.

7. Contributors to JModelica.org 1.3.0

Christian Andersson
Tove Bergdahl
Magnus G�fvert
Roberto Parrotto
Jesper Mattsson
Johan �kesson

Previous contributors:

Philip Nilsson
Jens Rantil
Philip Reutersw�rd