Used TinyModia 0.8.0 docs and examples -> Modia 0.8.0; adapted by changing TinyModia->Modia and a few minor fixes.

Author: MartinOtter

Manifest.toml

@@ -1,7 +1,7 @@
 name = "Modia"
 uuid = "cb905087-75eb-5f27-8515-1ce0ec8e839e"
 authors = ["Hilding Elmqvist <[email protected]>", "Martin Otter <[email protected]>"]
-version = "0.4.1-dev"
+version = "0.5.0"
 
 [deps]
 DifferentialEquations = "0c46a032-eb83-5123-abaf-570d42b7fbaa"
@@ -11,8 +11,8 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
 
 [compat]
-DifferentialEquations = "6.16"
-ModiaLang = "0.7.2"
+DifferentialEquations = "6.17, 6.16"
+ModiaLang = "0.8.0"
 Reexport = "1.0, 0.2"
 Unitful = "1.6, 1.5, 1.4, 1.3"
-julia = "1.6, 1.5"
+julia = "1.7, 1.6, 1.5"

Project.toml

@@ -1,4 +1,4 @@
-using Documenter, Modia, ModiaLang, ModiaPlot
+using Documenter, Modia, ModiaLang, ModiaResult, ModiaPlot_PyPlot
 
 makedocs(
   #modules  = [Modia],
@@ -7,14 +7,15 @@ makedocs(
   format = Documenter.HTML(prettyurls = false),
   pages    = [
      "Home"      => "index.md",
-	 "Modia Tutorial"  => Any[
-                              "tutorial/GettingStarted.md",
-                              "tutorial/Modeling.md",
-                              "tutorial/Simulation.md",
-                              "tutorial/FloatingPointTypes.md",
-                              "tutorial/Appendix.md"
-                          ],
+	 "Tutorial"  => [
+       "tutorial/Tutorial.md"
+       "tutorial/GettingStarted.md"
+       "tutorial/Modeling.md"
+       "tutorial/Simulation.md"
+       "tutorial/FloatingPointTypes.md"
+       "tutorial/Appendix.md"
+      ],
   	 "Functions" => "Functions.md",
      "Internal"  => "Internal.md"
-  ]
+  ]  
 )

docs/make.jl

@@ -4,6 +4,7 @@
 CurrentModule = ModiaLang
 ```
 
+
 ## Instantiation
 
 ```@docs
@@ -17,17 +18,66 @@ instantiateModel
 simulate!
 ```
 
-## Plotting
 
-The results of a simulation of a model `instantiatedModel` can be visualized with
-function [ModiaPlot.plot](https://modiasim.github.io/ModiaPlot.jl/stable/Functions.html#ModiaPlot.plot)
-that produces line plots of the result time series.
-A variable `a.b.c` is identified by a String key `"a.b.c"`.
+## Linearization
+
+```@docs
+linearize!
+```
+
+
+## Results and Plotting
+
+The simulation result of a model `instantiatedModel` supports the abstract interface
+[ModiaResult](https://modiasim.github.io/ModiaResult.jl/stable/index.html) and
+exports them, so the functions can be accessed without prefixing them with `Modia`.
+The following functions are provided (for details see 
+[Functions of ModiaResult](https://modiasim.github.io/ModiaResult.jl/stable/Functions.html#Functions-of-ModiaResult)):
+
+```@meta
+CurrentModule = ModiaLang
+```
+
+| Functions                        | Description                                       |
+|:---------------------------------|:--------------------------------------------------|
+| `@usingModiaPlot`        | Expands into `using ModiaPlot_<PlotPackageName>`          |
+| `usePlotPackage`         | Define the plot package to be used.                       |
+| `usePreviousPlotPackage` | Define the previously defined plot package to be used.    |
+| `currentPlotPackage`     | Return name defined with `usePlotPackage`                 |
+| `resultInfo`             | Return info about the result as [DataFrame](https://github.com/JuliaData/DataFrames.jl) table            |
+| `printResultInfo`        | Print info of the result on stdout.                       |
+| `rawSignal`              | Return raw signal data given the signal name.             |
+| `getPlotSignal`          | Return signal data prepared for a plot package.           |
+| `defaultHeading`         | Return default heading of a result.                       |
+| `signalNames`            | Return all signal names.                                  |
+| `timeSignalName`         | Return the name of the time signal.                       |
+| `hasOneTimeSignal`       | Return true if one time signal present.                   |
+| `hasSignal`              | Return true if a signal name is known.                    |
+
+
+The following functions are available after `ENV["MODIA_PLOT"] = XXX` or
+`@usingModiaPlot(XXX)` have been executed
+(for details see 
+[Functions of Plot Package](https://modiasim.github.io/ModiaResult.jl/stable/Functions.html#Functions-of-Plot-Package)):
+
+
+| Functions          | Description                                               |
+|:-------------------|:----------------------------------------------------------|
+| `plot`             | Plot simulation results in multiple diagrams/figures.     |
+| `saveFigure`       | Save figure in different formats on file.                 |
+| `closeFigure`      | Close one figure                                          |
+| `closeAllFigures`  | Close all figures                                         |
+| `showFigure`       | Show figure in window (only GLMakie, WGLMakie)            |
+
+
+A Modia variable `a.b.c` is identified by a String key `"a.b.c"`.
 The legends/labels of the plots are automatically constructed by the
 names and units of the variables. Example:
 
 ```julia
-using ModiaPlot
+using Modia
+@usingModiaPlot
+
 instantiatedModel = @instantiatedModel(...)
 simulate!(instantiatedModel, ...)
 plot(instantiatedModel,
@@ -40,25 +90,16 @@ generates the following plot:
 
 ![Matrix-of-Plots](../resources/images/matrix-of-plots.png)
 
-The underlying line plot is generated by [GLMakie](https://github.com/JuliaPlots/GLMakie.jl).
-
-
-## Inquiries
-
-```@meta
-CurrentModule = ModiaLang
-```
 
-```@docs
-get_result
-get_lastValue
-```
+## PathPlanning
 
-```@meta
-CurrentModule = ModiaPlot
-```
+There are some pre-defined functions to define reference paths
 
 ```@docs
-hasSignal
-getNames
-```
+PTP_path
+pathEndTime
+getPosition!
+getPosition
+getIndex
+getPath
+```

docs/resources/images/SimpleModel.png

@@ -21,4 +21,17 @@ addToResult!
 getFloatType
 baseType
 measurementToString
-```
+```
+
+## Inquiries in Model
+
+```@docs
+isInitial
+isTerminal
+isEvent
+isFirstEventIteration
+isFirstEventIterationDirectlyAfterInitial
+isAfterSimulationStart
+isZeroCrossing
+storeResults
+```

docs/resources/images/SimpleModel_GLMakie.png

@@ -1,38 +1,113 @@
 # Modia Documentation
 
-[Modia](https://github.com/ModiaSim/Modia.jl) is a Julia package for modeling and simulation of multidomain engineering systems described by differential equations, algebraic equations, and (space-discretized) partial differential equations. It shares many powerful features of the [Modelica language](https://www.modelica.org/modelicalanguage), together with features not available in Modelica. 
+[Modia](https://github.com/ModiaSim/Modia.jl) is a minimalistic environment in form of a Julia package to model and simulate physical systems (electrical, mechanical, thermo-dynamical, etc.) described by differential and algebraic equations. A user defines a model on a high level with model components (like a mechanical body, an electrical resistance, or a pipe) that are physically connected together. A model component is constructed by "expression = expression" equations. The defined model is symbolically processed (for example, equations might be analytically differentiated) with algorithms from package [ModiaBase.jl](https://github.com/ModiaSim/ModiaBase.jl). From the transformed model a Julia function is generated that is used to simulate the model with integrators from [DifferentialEquations.jl](https://github.com/SciML/DifferentialEquations.jl).
+The basic type of the floating point variables is usually `Float64`, but can be set to any
+type `FloatType<:AbstractFloat` via `@instantiateModel(..., FloatType = xxx)`, for example
+it can be set to `Float32, DoubleFloat, Measurement{Float64}, StaticParticles{Float64,100}`.
 
-A user defines a model on a high level with model components (like an electrical resistance, a rotational inertia, a rod with heat transfer, a PI controller etc.) that are physically connected together. A model component is constructed by "expression = expression" equations. The defined model is symbolically transformed to ODE form dx/dt = f(x,t). For example, equations might be analytically differentiated, ODE states selected, linear equation systems numerically solved when evaluating the transformed model. From the transformed model a Julia function is generated that is used to simulate the model with integrators from [DifferentialEquations](https://github.com/SciML/DifferentialEquations.jl). Simulation results can be plotted with [ModiaPlot](https://github.com/ModiaSim/ModiaPlot.jl), that provides a convenient interface to [GLMakie](https://github.com/JuliaPlots/GLMakie.jl) line plots.
-
-Other packages from the Julia eco-systems that are specially supported:
-
-- [Unitful](https://github.com/PainterQubits/Unitful.jl) to define and process physical units.
-- [Measurements](https://github.com/JuliaPhysics/Measurements.jl) to perform simulations with uncertain parameters and initial values with linear propagation theory.
-- [MonteCarloMeasurements](https://github.com/baggepinnen/MonteCarloMeasurements.jl) to perform simulations with uncertain parameters and initial values with particle theory.
+## Installation
 
+The package is registered and is installed with (Julia >= 1.5 is required):
 
-## Installation
+```julia
+julia> ]add Modia
+```
 
-Modia and ModiaPlot are registered and are installed with (Julia >= 1.5 is required):
+Furthermore, one or more of the following packages should be installed in order 
+to be able to generate plots:
 
 ```julia
-julia> ]add Modia, ModiaPlot
+julia> ]add ModiaPlot_PyPlot        # if plotting with PyPlot desired
+        add ModiaPlot_GLMakie       # if plotting with GLMakie desired
+        add ModiaPlot_WGLMakie      # if plotting with WGLMakie desired
+        add ModiaPlot_CairoMakie    # if plotting with CairoMakie desired
 ```
 
 It is recommended to also add the following packages, in order that all tests and examples can be executed in your standard environment:
 
 ```julia
-julia> ]add Measurements 
-        add MonteCarloMeasurements
-        add Distributions
-        add Interpolations
+julia> ]add Unitful, DifferentialEquations, Measurements
+        add MonteCarloMeasurements, Distributions
 ```
 
 ## Release Notes
 
-### Version 0.4.0
 
-- Initial version of new Modia design.
+### Version 0.8.0
+
+- Improved scalability by using OrderedDicts instead of named tuples for models, variables and parameter modifications.
+- Speed improvements for structural and symbolic algorithms.
+- Added support for state events, time events and synchronous operators.
+- Added support for mixed linear equation systems having Real and Boolean unknowns.
+- Added support for user-defined components defined by structs and functions
+  (multibody modeling with Modia3D is based on this feature).
+  This makes it possible to utilize algorithms specialized for a component.
+- Added support for numerical and analytic linearization.
+- Added support for propagation of parameters (e.g. deep in a model, the value of a parameter can be defined as a function of some top level parameter and this parameter is changed before simulation starts).
+- New small model libraries Translational.jl and PathPlanning.jl added.
+- Result storage changed: `sol = simulate!(...)` calls internally `sol = solve(..)` from   DifferentialEquations.jl. `sol` contains time and the states at the communication time grid and
+  at events. This is now kept in simulate(..), so the return value of simulate!(..) can be exactly used as if `solve(..)` would have been used directly.
+- The plot(..) command now supports the following underlying plot packages: 
+  [PyPlot](https://github.com/JuliaPy/PyPlot.jl),
+  [GLMakie](https://github.com/JuliaPlots/GLMakie.jl),
+  [WGLMakie](https://github.com/JuliaPlots/WGLMakie.jl), and
+  [CairoMakie](https://github.com/JuliaPlots/CairoMakie.jl).
+  It is also possible to select `NoPlot`, to ignore `plot(..)` calls 
+  or `SilenNoPlot` to ignore `plot(..)` calls silently. The latter is useful for `runtests.jl`.
+  Note, often [PyPlot](https://github.com/JuliaPy/PyPlot.jl) is the best choice.
+
+Changes that are **not backwards compatible** to version 0.7.x:
+
+- Models are OrderedDicts and no longer NamedTuples.
+
+- simulate!(..): 
+  - If FloatType=Float64 and no algorithm is defined, then Sundials.CVODE\_BDF() is used
+    instead of the default algorithm of DifferentialEquations as in 0.7. The reason is that Modia models
+    are usually large and expensive to evaluate and have often stiff parts, so that multi-step
+    methods are often by far the best choice. CVODE_BDF() seems to be a good choice in many applications
+    (another algorithm should be used, if there are many events, highly oscillatory vibrations, or if all states are non-stiff). 
+  - The default value of `stopTime` is equal to `startTime` (which has a default value of 0.0 s), and is no longer 1.0 s.
+
+- Plotting is defined slightly differently (`@useModiaPlot`, instead of `using ModiaPlot`).
+
+
+### Version 0.7.3
+
+- Evaluation and propagation of parameter expressions (also in simulate!(..., merge=Map(...))).
+  Propagation of start/init values of states is not yet supported.
+
+- State events supported.
+
+
+### Version 0.7.2
+
+- Missing dependency of Test package added.
+
+### Version 0.7.1
+
+- Variable constructor `Var(...)` introduced. For example:
+  `v = input | Var(init = 1.2u"m")`. 
+  For details see section [A.1 Var constructor](@ref).
+
+- Functions are called in the scope where macro [`@instantiateModel`](@ref) is called.
+
+- New arguments of function [`simulate!`](@ref):
+  - Parameter and init/start values can be changed with argument `merge`.
+  - A simulation can be checked with argument `requiredFinalStates`.
+  - Argument `logParameters` lists the parameter and init/start values used for the simulation.
+  - Argument `logStates` lists the states, init, and nominal values used for the simulation.
+
+- `end` in array ranges is supported, for example `v[2:end]`.
+
+- New (small) model library `Modia/models/HeatTransfer.jl`.
+
+- Modia Tutorial improved.
+
+- [Functions](@ref) docu improved.
+
+### Version 0.7.0
+
+- Initial version, based on code developed for Modia 0.6 and ModiaMath 0.6.
 
 
 ## Main developers