Various improvements

Author: MartinOtter

Manifest.toml

@@ -1,8 +1,27 @@
+authors = ["Hilding Elmqvist <[email protected]>", "Martin Otter <[email protected]>"]
 name = "Modia"
 uuid = "cb905087-75eb-5f27-8515-1ce0ec8e839e"
-authors = ["Hilding Elmqvist <[email protected]>", "Martin Otter <[email protected]>"]
 version = "0.8.2"
 
+[compat]
+DataFrames = "1"
+DifferentialEquations = "7"
+FiniteDiff = "2"
+ForwardDiff = "0.10"
+JSON = "0.21"
+Measurements = "2"
+ModiaBase = "0.11"
+ModiaResult = "0.4.1"
+MonteCarloMeasurements = "1"
+OrderedCollections = "1"
+RecursiveFactorization = "0.2"
+Reexport = "1"
+StaticArrays = "1"
+Sundials = "4.4"
+TimerOutputs = "0.5"
+Unitful = "1"
+julia = "1.7"
+
 [deps]
 DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
 DifferentialEquations = "0c46a032-eb83-5123-abaf-570d42b7fbaa"
@@ -25,21 +44,5 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 TimerOutputs = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f"
 Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
 
-[compat]
-DataFrames = "1"
-DifferentialEquations = "7"
-FiniteDiff = "2"
-ForwardDiff = "0.10"
-JSON = "0.21"
-Measurements = "2"
-ModiaBase = "0.10"
-ModiaResult = "0.4.1"
-MonteCarloMeasurements = "1"
-OrderedCollections = "1"
-RecursiveFactorization = "0.2"
-Reexport = "1"
-StaticArrays = "1"
-Sundials = "4.4"
-TimerOutputs = "0.5"
-Unitful = "1"
-julia = "1.7"
+[extras]
+CPUSummary = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9"

Project.toml

@@ -38,8 +38,50 @@ functionalities of these packages.
 
 ### Version 0.8.2
 
+- New exported functions
+  - modelToJSON(model; expressionsAsStrings=true)
+  - JSONToModel(json)
+  - writeModel(filename, model; log=true) 
+  - readModel(filename; log=true)
+  writeModel saves the model in JSON format on file and readModel reads the model from a JSON file.
+
+- `Modia/examples/ServoSystem.jl` enhanced, so that the hierarchical model with units is
+  first stored in JSON format on file, then the model is read from file, a parameter is modified,
+  and then the model is passed to @instantiateModel(..).
+ 
+- `@instantiateModel(...)`:
+  - `@instantiateModel(..., logCode=true, ...)` provides now correct unit type casts for scalars.
+  - `@instantiateModel(..., saveCodeOnFile=fileName, ...)` stores the generated code on file `fileName`.
+  - Automatically use `@instantiatedModel(..., unitless=true, ..)`, if `FloatType = MonteCarloMeasurements.XXX`,
+    because there are easily cases where this fails, if units are present.
+
+- `@showModel model`: Nicer pretty print if model is hierarchical.
+
+- New function `Modia.unitAsString(unitOfQuantity)`,
+  see Unitful issue 412 (https://github.com/PainterQubits/Unitful.jl/issues/412).
+
+- Remove empty hierarchies in model parameters (seen with `simulate!(..., logParameters=true)`).
+
 - Memory allocation reduced if states or tearing variables are SVectors.
 
+- Improved casting and checking of types in the generated code
+  (see new test model Modia/test/TestUnitAsString.jl). 
+  
+- Moved ModiaBase.Symbolic.makeDerVar from ModiaBase to Modia (because makeDerVar needs FloatType for
+  generating type-stable code and FloatType is available in Modia but not in ModiaBase).
+
+- Github actions workflow added for automatic tests on Linux/Windows/MacOS, for pull requests on main.
+
+**Bug fixes**
+
+- Fixed issue with unit on macOS (exponents had been displayed as Unicode superscripts when converting 
+  the unit to a string, leading to errors in the further processing).
+  
+- Hide result only if `Var(hideResult=true)` (previously, hideResult=false was treated as true).
+
+- `Modia/models/Rotational.jl`: Change some Int to Float64 values, because errors occured in some situations.
+
+
 ### Version 0.8.1
 
 - Missing file Modia/test/TestLinearEquations.jl added.

docs/src/index.md

@@ -98,27 +98,31 @@ Servo = Model(
 
 
 TestServo = Model(
-    ks    = 0.8,
+    ks    = 0.4,
     Ts    = 0.08u"s",
     ramp  = Ramp  | Map(duration=1.18u"s", height=2.95),
     servo = Servo | Map(ks=:(up.ks), Ts=:(up.Ts)),
-    load  = Inertia | Map(J=170u"kg*m^2"),
-    equations =:[load.flange_b.tau = 0u"N*m"],
+    load  = Inertia | Map(J=170.0u"kg*m^2"),
+    equations =:[load.flange_b.tau = 0.0u"N*m"],
     connect = :[
         (ramp.y        , servo.refSpeed)
         (servo.flange_b, load.flange_a) ]
 )
 
+file = joinpath(pwd(), "TestServo.json")
+writeModel(file, TestServo)
+TestServo = readModel(file) | Map(ks = 0.8)
+
 plotVariables = [("ramp.y", "load.w")         "servo.speedError.y";
                  "servo.gear.spring.phi_rel"  "servo.motor.currentSensor.i"]
 
-testServo1 = @instantiateModel(TestServo)
+testServo1 = @instantiateModel(TestServo, saveCodeOnFile="TestServo.jl")
 println("Simulate")
 @time simulate!(testServo1, Tsit5(), stopTime=2.0, tolerance=1e-6, requiredFinalStates = 
     [7.320842067204029, 9.346410309487013, 355.30389168655955, 2.792544498835712, 429.42665751348284, 311.7812493890421, 4.089776248793499, 2.969353608933471])
 plot(testServo1, plotVariables, figure=1)
 
-
+#=
 println("\nServo with uncertainties")
 using Modia.Measurements
 TestServoWithUncertainties = TestServo | Map(
@@ -139,6 +143,6 @@ TestServoWithMonteCarlo = TestServo | Map(
 testServo3 = @instantiateModel(TestServoWithMonteCarlo, FloatType = Modia.MonteCarloMeasurements.StaticParticles{Float64,nparticles}, unitless=true)
 @time simulate!(testServo3, Tsit5(), stopTime=2.0, tolerance=1e-6)
 plot(testServo3, plotVariables, figure=3)
-
+=#
 
 end

examples/ServoSystem.jl

@@ -17,21 +17,36 @@ fieldnames(typeof(integrator)) = (:sol, :u, :du, :k, :t, :dt, :f, :p, :uprev, :u
 """
     baseType(T)
 
-Return the base type of a type T.
+Return the base type of a type T, according to the following definition.
+
+```julia
+baseType(::Type{T})                                           where {T}     = T
+baseType(::Type{Unitful.Quantity{T,D,U}})                     where {T,D,U} = T
+baseType(::Type{Measurements.Measurement{T}})                 where {T}     = T
+baseType(::Type{MonteCarloMeasurements.Particles{T,N}})       where {T,N}   = T
+baseType(::Type{MonteCarloMeasurements.StaticParticles{T,N}}) where {T,N}   = T
+```
 
 # Examples
 ```
 baseType(Float32)                # Float32
 baseType(Measurement{Float64})   # Float64
 ```
 """
-baseType(::Type{T})                                           where {T}                  = T
-baseType(::Type{Measurements.Measurement{T}})                 where {T<:AbstractFloat}   = T
-baseType(::Type{MonteCarloMeasurements.Particles{T,N}})       where {T<:AbstractFloat,N} = T
-baseType(::Type{MonteCarloMeasurements.StaticParticles{T,N}}) where {T<:AbstractFloat,N} = T
+baseType(::Type{T})                                           where {T}     = T
+baseType(::Type{Unitful.Quantity{T,D,U}})                     where {T,D,U} = T
+baseType(::Type{Measurements.Measurement{T}})                 where {T}     = T
+baseType(::Type{MonteCarloMeasurements.Particles{T,N}})       where {T,N}   = T
+baseType(::Type{MonteCarloMeasurements.StaticParticles{T,N}}) where {T,N}   = T
+
+isQuantity(              ::Type{T}) where {T} = T <: Unitful.Quantity         || T <: MonteCarloMeasurements.AbstractParticles && baseType(T) <: Unitful.Quantity
+isMeasurements(          ::Type{T}) where {T} = T <: Measurements.Measurement || T <: Unitful.Quantity && baseType(T) <: Measurements.Measurement
+isMonteCarloMeasurements(::Type{T}) where {T} = T <: MonteCarloMeasurements.AbstractParticles
 
-Base.floatmax(::Type{MonteCarloMeasurements.Particles{T,N}})       where {T<:AbstractFloat,N} = Base.floatmax(T)
-Base.floatmax(::Type{MonteCarloMeasurements.StaticParticles{T,N}}) where {T<:AbstractFloat,N} = Base.floatmax(T)
+Base.floatmax(::Type{Unitful.Quantity{T,D,U}})                     where {T,D,U} = Base.floatmax(T)
+Base.floatmax(::Type{Measurements.Measurement{T}})                 where {T}     = Base.floatmax(T)
+Base.floatmax(::Type{MonteCarloMeasurements.Particles{T,N}})       where {T,N}   = Base.floatmax(T)
+Base.floatmax(::Type{MonteCarloMeasurements.StaticParticles{T,N}}) where {T,N}   = Base.floatmax(T)
 
 
 """
@@ -1528,7 +1543,7 @@ Symbol `functionName` as function name. By `eval(code)` or
 
 - `hasUnits::Bool`: = true, if variables have units. Note, the units of the state vector are defined in equationinfo.
 """
-function generate_getDerivatives!(AST::Vector{Expr}, equationInfo::Modia.EquationInfo,
+function generate_getDerivatives!(FloatType, TimeType, AST::Vector{Expr}, equationInfo::Modia.EquationInfo,
                                   parameters, variables, previousVars, preVars, holdVars, functionName::Symbol;
                                   pre::Vector{Symbol} = Symbol[], hasUnits=false)
 
@@ -1643,9 +1658,12 @@ function generate_getDerivatives!(AST::Vector{Expr}, equationInfo::Modia.Equatio
     end
 
     # Generate code of the function
+    # temporarily removed: _m.time = $TimeType(Modia.getValue(_time))
     code = quote
-                function $functionName(_x, _m::Modia.SimulationModel{_FloatType,_TimeType}, _time)::Nothing where {_FloatType,_TimeType}
-                    _m.time = _TimeType(Modia.getValue(_time))
+                function $functionName(_x, _m::Modia.SimulationModel{$FloatType,$TimeType}, _time::$TimeType)::Nothing
+                    _FloatType = $FloatType
+                    _TimeType = $TimeType
+                    _m.time = _time
                     _m.nGetDerivatives += 1
                     instantiatedModel = _m
                     _p = _m.evaluatedParameters

src/CodeGeneration.jl

@@ -8,7 +8,7 @@ Encoding and decoding Modia models as JSON.
 """
 module JSONModel
 
-export modelToJSON, JSONToModel, cloneModel
+export modelToJSON, JSONToModel, cloneModel, writeModel, readModel
 
 import JSON
 using Modia
@@ -31,7 +31,7 @@ function encodeModel(model, expressionsAsStrings=true)
     Base.remove_linenums!(model)
     model = removeBlock(model)
     if typeof(model) <: Quantity
-        return Dict(:_value => ustrip.(model), :_unit=>string(unit(model)))
+        return Dict(:_value => ustrip.(model), :_unit=>Modia.unitAsString(unit(model)))
     elseif expressionsAsStrings && typeof(model) == Expr
         return Dict(:_Expr=>string(model))
     elseif typeof(model) == Expr
@@ -80,10 +80,10 @@ Encodes a model suitable to convert to a JSON string.
 function decodeModel(jModel)
     if typeof(jModel) <: AbstractDict && length(keys(jModel)) == 2 && "_value" in keys(jModel) && "_unit" in keys(jModel)
         unit = jModel["_unit"]
-        unit = replace(unit, ' ' => '*')  # Workaround for https://github.com/PainterQubits/Unitful.jl/issues/391
+        #unit = replace(unit, ' ' => '*')  # Workaround for https://github.com/PainterQubits/Unitful.jl/issues/391  # Remove, since already correctly done in encodeModel(...)
         return jModel["_value"]*uparse(unit)
     elseif typeof(jModel) <: AbstractDict && length(keys(jModel)) == 1 && "_Expr" in keys(jModel) 
-        return Meta.parse(jModel["_Expr"])
+        return Base.remove_linenums!( Meta.parse(jModel["_Expr"]) )  # without remove_linenums!, there are errors later with if-expressions.
     elseif typeof(jModel) <: AbstractDict && length(keys(jModel)) == 1 && "_Symbol" in keys(jModel) 
         return Symbol(jModel["_Symbol"])
     elseif typeof(jModel) <: AbstractDict && length(keys(jModel)) == 2 && "head" in keys(jModel) && "args" in keys(jModel)
@@ -122,6 +122,32 @@ function JSONToModel(json)
 end
 
 
+"""
+    writeModel(filename::String, model; log=true)
+    
+Write model in JSON format on file `filename`.
+"""
+function writeModel(filename::String, model::AbstractDict; log=true) 
+    if log
+        println("  Write model in JSON format on file \"$filename\"")
+    end
+    write(filename, modelToJSON(model))
+end
+
+
+"""
+    model = readModel(filename::AbstractString; log=true)
+    
+Read a model that is stored in JSON format on file `filename` and return it.
+"""
+function readModel(filename::String; log=true)
+    if log
+        println("  Read model from JSON file \"$filename\"")
+    end
+    JSONToModel( read(filename,String) )
+end
+
+
 
 """
     modelClone = cloneModel(model; expressionsAsStrings=true)

src/JSONModel.jl

@@ -10,7 +10,7 @@ module Modia
 
 const path = dirname(dirname(@__FILE__))   # Absolute path of package directory
 const Version = "0.8.2"
-const Date = "2022-03-04"
+const Date = "2022-03-08"
 const modelsPath = joinpath(Modia.path, "models")
 
 print(" \n\nWelcome to ")
@@ -56,8 +56,7 @@ export get_xNames
 export registerExtraSimulateKeywordArguments
 export get_extraSimulateKeywordArgumentsDict
 
-
-
+export modelToJSON, JSONToModel, writeModel, readModel
 
 import Sundials
 const  CVODE_BDF = Sundials.CVODE_BDF
@@ -141,6 +140,25 @@ Implementation is performed in the following way:
 """
 unitAsString(unitOfQuantity::Unitful.FreeUnits) = replace(repr(unitOfQuantity,context = Pair(:fancy_exponent,false)), " " => "*")
 
+"""
+    quantityType = quantity(numberType, numberUnit::Unitful.FreeUnits)
+    
+Return the quantity type given the numberType and the numberUnit.
+
+# Example
+```julia
+mutable struct Data{FloatType <: AbstractFloat}
+    velocity::quantity(FloatType, u"m/s")
+end
+
+v = Data{Float64}(2.0u"mm/s")
+@show v                         # v = 
+```
+"""
+quantity(numberType, numberUnit::Unitful.FreeUnits) = Quantity{numberType, dimension(numberUnit), typeof(numberUnit)} 
+
+quantityTypes(::Type{Unitful.Quantity{T,D,U}}) where {T,D,U} = (T,D,U)
+
 
 include("EquationAndStateInfo.jl")
 include("StateSelection.jl")
@@ -155,14 +173,15 @@ include("SimulateAndPlot.jl")
 include("ReverseDiffInterface.jl")
 include("PathPlanning.jl")
 include("JSONModel.jl")
+using .JSONModel
 
 # include("IncidencePlot.jl")
 # using .IncidencePlot
 # Base.Experimental.@optlevel 0
 
 const drawIncidence = false
 
-
+include("Symbolic.jl")
 include("ModiaLang.jl")
 
 end

src/Modia.jl

@@ -457,7 +457,7 @@ function stateSelectionAndCodeGeneration(modStructure, Gexplicit, name, modelMod
     #        solution = :(try $solution; catch e; println("Failure executing: ", $sol); printstyled(stderr,"ERROR: ", bold=true, color=:red);
     #        printstyled(stderr,sprint(showerror,e), color=:light_red); println(stderr); end)
         end
-        solution = makeDerVar(solution, parameters, inputs, evaluateParameters)
+        solution = makeDerVar(solution, parameters, inputs, FloatType, evaluateParameters)
         if logCalculations
             var = string(unknowns[v])
             solutionString = string(solution)
@@ -475,7 +475,7 @@ function stateSelectionAndCodeGeneration(modStructure, Gexplicit, name, modelMod
             return nothing
         end
         if isexpr(lhs, :tuple) && all(a == 0 for a in lhs.args) || lhs == :(0)
-            eq_rhs = makeDerVar(:($rhs), parameters, inputs, evaluateParameters)
+            eq_rhs = makeDerVar(:($rhs), parameters, inputs, FloatType, evaluateParameters)
             if unitless
                 eqs = eq_rhs
             else
@@ -486,8 +486,8 @@ function stateSelectionAndCodeGeneration(modStructure, Gexplicit, name, modelMod
         #    eq_lhs = makeDerVar(:($lhs), parameters, inputs, evaluateParameters)
         #    eqs =  :( ($eq_rhs .-= $eq_lhs) )
         else
-            eq_rhs = makeDerVar(:($rhs), parameters, inputs, evaluateParameters)
-            eq_lhs = makeDerVar(:($lhs), parameters, inputs, evaluateParameters)
+            eq_rhs = makeDerVar(:($rhs), parameters, inputs, FloatType, evaluateParameters)
+            eq_lhs = makeDerVar(:($lhs), parameters, inputs, FloatType, evaluateParameters)
             if unitless
                 eqs = :( $eq_rhs .- $eq_lhs )
             else
@@ -687,7 +687,7 @@ function stateSelectionAndCodeGeneration(modStructure, Gexplicit, name, modelMod
         if useNewCodeGeneration
             @timeit to "generate_getDerivativesNew!" code = generate_getDerivativesNew!(AST, newFunctions, modelModule, equationInfo, [:(_p)], vcat(:time, [Symbol(u) for u in unknowns]), previousVars, preVars, holdVars, :getDerivatives, hasUnits = !unitless)
         else
-            @timeit to "generate_getDerivatives!" code = generate_getDerivatives!(AST, equationInfo, [:(_p)], extraResults, previousVars, preVars, holdVars, :getDerivatives, hasUnits = !unitless)
+            @timeit to "generate_getDerivatives!" code = generate_getDerivatives!(FloatType, TimeType, AST, equationInfo, [:(_p)], extraResults, previousVars, preVars, holdVars, :getDerivatives, hasUnits = !unitless)
         end
     else
 #        code = generate_getDerivatives!(AST, equationInfo, Symbol.(keys(parameters)), extraResults, :getDerivatives, hasUnits = !unitless)
@@ -888,6 +888,11 @@ See documentation of macro [`@instantiateModel`]
 function instantiateModel(model; modelName="", modelModule=nothing, source=nothing, FloatType = Float64, aliasReduction=true, unitless=false,
     log=false, logModel=false, logDetails=false, logStateSelection=false, logCode=false,
     logExecution=logExecution, logCalculations=logCalculations, logTiming=false, evaluateParameters=false, saveCodeOnFile="")
+    if isMonteCarloMeasurements(FloatType) && !unitless
+        unitless=true
+        printstyled("  @instantiateModel(...,unitless=true, ..) set automatically, because\n  FloatType=MonteCarloMeasurements often fails if units are involved.\n", color=:red)
+    end
+    
     #try
     #    model = JSONModel.cloneModel(model, expressionsAsStrings=false)
         println("\nInstantiating model $modelName\n  in module: $modelModule\n  in file: $source")