Further improvements of built-in components

Author: MartinOtter

docs/src/index.md

@@ -44,13 +44,19 @@ functionalities of these packages.
 
 ### Version 0.10.0
 
-- 
+- Initial support of segmented simulations where the number of states can change during simulation.
+  For examples, see `Modia/test/TestHeatTransfer2.jl` and models in directory `Modia3D/test/Segmented`
+  (of release 0.12.0 and later). The tutorial will be updated for this feature in an upcoming version.
+  
 
-**Non-backwards** compatible changes (should usually not influende user models)
+**Non-backwards** compatible changes 
+
+These changes should usually not influence user models.
 
 - `_buildFunction = <functionName>` changed to `_buildFunction = Par(functionName = <functionName>)` and
-  additional argument `unitless` added to `<functionName>`.
-- `_instantiateFunction = Par(..)` changed to `_initSegmentFunction = Par(..)`
+  changed argument list of `<functionName>`.
+- `_instantiateFunction = Par(..)` changed to `_initSegmentFunction = Par(functionName = <functionName>)`
+  and changed argument list of `<functionName>`.
 
 
 ### Version 0.9.4

models/HeatTransfer.jl

@@ -95,8 +95,8 @@ For more details see Appendix B1 of [DOI: 10.3390/electronics12030500](https://d
 - `der(T)': Vector of derivatives of `T`.
 """
 InsulatedRod2 = Model(; 
-    _buildFunction       = Par(functionName = :(buildInsulatedRod2!)),              # Called once in @instantiateModel(..) before getDerivatives!(..) is generated 
-    _initSegmentFunction = Par(functionName = :(initInsulatedRod2ForNewSegment!)),  # Called once before initialization of a new simulation segment
+    _buildFunction       = Par(functionName = :(build_InsulatedRod2!)),        # Called once in @instantiateModel(..) before getDerivatives!(..) is generated 
+    _initSegmentFunction = Par(functionName = :(initSegment_InsulatedRod2!)),  # Called once before initialization of a new simulation segment
     L      = 1.0u"m",                # Length of rod
     A      = 0.0004u"m^2",           # Rod area
     rho    = 7500.0u"kg/m^3",        # Density of rod material

models/HeatTransfer/InsulatedRod2.jl

@@ -7,7 +7,6 @@
 # Structure holding the internal memory of the insulated rod
 mutable struct InsulatedRodStruct{FloatType}
   # Parameters
-  path::String               # path name of instance
   Ge::FloatType              # = lambda*A/dx
   Ge2::FloatType             # = 2*Ge
   k::FloatType               # = Ge / (c*rho*A*dx)
@@ -19,17 +18,35 @@ mutable struct InsulatedRodStruct{FloatType}
 
   # Start index of state and state derivative vectors
   T_startIndex::Int
+  
+  InsulatedRodStruct{FloatType}() where {FloatType} = new()
+end
+
+
+# Called from @instantiateModel(..) before getDerivatives!(..) is generated
+function build_InsulatedRod2!(model::AbstractDict, FloatType, TimeType, unitless::Bool, ID, pathAST)
+    model = model | Model(
+        insRod  = Var(hideResult=true),  # InsulatedRodStruct instance (an equation to return this variable is generated by _buildFunction)
+        success = Var(hideResult=true),  # Dummy return argument
+        equations = :[
+            # copy states into insRod.T and return insRod
+            insRod = openInsulatedRod!(instantiatedModel, $ID)
+      
+            # equations at the boundaries
+            port_a.Q_flow = getGe2(insRod, Val($unitless))*(port_a.T - getT1(  insRod, Val($unitless)))
+            port_b.Q_flow = getGe2(insRod, Val($unitless))*(port_b.T - getTend(insRod, Val($unitless)))
 
-  InsulatedRodStruct{FloatType}(path::String) where {FloatType} = new(path,false)
+            # compute insRod.der_T and copy it into state derivatives
+            success = computeInsulatedRodDerivatives!(instantiatedModel, insRod, port_a.T, port_b.T)   # instantiatedModel is provided in the generated code
+        ])
+
+  return (model, InsulatedRodStruct{FloatType}())
 end
 
 
 # Called once before initialization of first simulation segment
-function initInsulatedRod2!(obj::InsulatedRodStruct{FloatType}; L, A, rho, lambda, c, T0, nT)::Nothing where {FloatType}
-    #L, A, rho=7500.0u"kg/m^3", lambda=74.0u"W/(m*K)", c=450.0u"J/(kg*K)", T0=293.15u"K", nT=1)::Nothing where {FloatType}
-
+function initFirstSegment_InsulatedRod2!(obj::InsulatedRodStruct{FloatType}; L, A, rho, lambda, c, T0, nT)::Nothing where {FloatType}
     # Convert to SI units, strip units and check that values are positives
-    path = obj.path
     #=
     @show L
     @Modia.strippedPositive!(path, L)
@@ -65,37 +82,13 @@ function initInsulatedRod2!(obj::InsulatedRodStruct{FloatType}; L, A, rho, lambd
 end
 
 
-# Called from @instantiateModel(..) before getDerivatives!(..) is generated
-function buildInsulatedRod2!(model::AbstractDict, FloatType, TimeType, unitless::Bool, buildDict, path)
-    pathAsString = Modia.modelPathAsString(path)
-    extraModelCode = Model(  # extra code to be merged with model
-        insRod  = Var(hideResult=true),  # InsulatedRodStruct instance (an equation to return this variable is generated by _buildFunction)
-        success = Var(hideResult=true),  # Dummy return argument
-        equations = :[
-            # copy states into insRod.T and return insRod
-            insRod = openInsulatedRod!(instantiatedModel, $pathAsString)
-      
-            # equations at the boundaries
-            port_a.Q_flow = getGe2(insRod, Val($unitless))*(port_a.T - getT1(  insRod, Val($unitless)))
-            port_b.Q_flow = getGe2(insRod, Val($unitless))*(port_b.T - getTend(insRod, Val($unitless)))
-
-            # compute insRod.der_T and copy it into state derivatives
-            success = computeInsulatedRodDerivatives!(instantiatedModel, insRod, port_a.T, port_b.T)   # instantiatedModel is provided in the generated code
-        ])
-
-  # Store build info in buildDict
-  buildDict[pathAsString] = InsulatedRodStruct{FloatType}(pathAsString)
-  return extraModelCode
-end
-
-
 # Called once before initialization of a new simulation segment
-function initInsulatedRod2ForNewSegment!(instantiatedModel::SimulationModel{FloatType,TimeType},
-                                         parameters::AbstractDict, path::String; log=false)::Nothing where {FloatType,TimeType}
-    obj::InsulatedRodStruct{FloatType} = instantiatedModel.buildDict[path]
-
+function initSegment_InsulatedRod2!(instantiatedModel::SimulationModel{FloatType,TimeType}, path::String, ID,
+                                    parameters::AbstractDict; log=false)::Nothing where {FloatType,TimeType}
+    obj::InsulatedRodStruct{FloatType} = Modia.get_instantiatedSubmodel(instantiatedModel, ID)
+    
     if Modia.isFirstInitialOfAllSegments(instantiatedModel)
-        initInsulatedRod2!(obj; parameters...)
+        initFirstSegment_InsulatedRod2!(obj; parameters...)
     end
 
     # Define a vector of new state and state derivative variables
@@ -105,8 +98,8 @@ end
 
 
 # Open an initialized InsulatedRod2 model and return a reference to it
-function openInsulatedRod!(instantiatedModel::SimulationModel{FloatType,TimeType}, path::String)::InsulatedRodStruct{FloatType} where {FloatType,TimeType}
-    obj::InsulatedRodStruct{FloatType} = instantiatedModel.buildDict[path]
+function openInsulatedRod!(instantiatedModel::SimulationModel{FloatType,TimeType}, ID)::InsulatedRodStruct{FloatType} where {FloatType,TimeType}
+    obj::InsulatedRodStruct{FloatType} = Modia.get_instantiatedSubmodel(instantiatedModel, ID)
     Modia.get_Vector_x_segmented_value!(instantiatedModel, obj.T_startIndex, obj.T)
     return obj
 end

src/CodeGeneration.jl

@@ -1666,6 +1666,15 @@ function addToResult!(m::SimulationModel{FloatType,TimeType}, x, time, w_invaria
 end
 
 
+"""
+    obj = get_instantiatedSubmodel(instantiatedModel, ID)
+    
+Return reference `obj` to an instantiated submodel struct, given `intantiatedModel` and the `ID` of the submodel.    
+"""
+get_instantiatedSubmodel(instantiatedModel, ID) = instantiatedModel.buildDict[ID]
+
+
+
 """
     index = new_x_segmented_variable!(
                 instantiatedModel::SimulationModel,

src/EvaluateParameters.jl

@@ -405,7 +405,7 @@ function propagateEvaluateAndInstantiate2!(m::SimulationModel{FloatType,TimeType
             if log
                 println(" 13:    +++ Instantiated $path: $instantiateFunction will be called to instantiate sub-model and define varying states\n\n")
             end
-            Core.eval(modelModule, :($instantiateFunction($m, $current, $path, log=$log)))
+            Core.eval(modelModule, :($instantiateFunction($m, $path, $path, $current, log=$log)))
             push!(m.instantiateFunctions, (instantiateFunction, current, path))
         end
         return current

src/Modia.jl

@@ -10,7 +10,7 @@ module Modia
 
 const path = dirname(dirname(@__FILE__))   # Absolute path of package directory
 const Version = "0.10.0"
-const Date = "2023-05-22"
+const Date = "2023-05-29"
 const modelsPath = joinpath(Modia.path, "models")
 
 print(" \n\nWelcome to ")

src/ModiaLang.jl

@@ -837,56 +837,55 @@ appendSymbol(path::Nothing, name::Symbol) = name
 appendSymbol(path         , name::Symbol) = :( $path.$name )
 
 """
-    modifiedModel = buildSubModels!(model, modelModule, FloatType, TimeType, unitless, buildDict::OrderedDict)
+    modifiedModel = buildSubmodels!(model, modelModule, FloatType, TimeType, unitless, buildDict::OrderedDict)
 
-Traverse `model` and for every `<subModel>` that is a `Model(..)` and has a key-value pair
-`:_buildFunction = <buildFunction>` and optionally `:_buildOption=<buildOption>`, call
+Traverse `model` and for every `<submodel>` that is a `Model(..)` and has a key-value pair
+`:_buildFunction = Par(functionName = <buildFunction>)` and optionally `:_buildOption=<buildOption>`, call
 
 ```
-buildCode = <buildFunction>(<subModel>, modelModule, FloatType::Type, TimeType::Type, unitless::Bool,
-                            buildDict::OrderedDict{String,Any},
-                            modelPath::Union{Expr,Symbol,Nothing},
-                            buildOption = <buildOption>)
+updatedSubmodel = <buildFunction>(submodel, FloatType::Type, TimeType::Type, unitless::Bool, 
+                      ID, pathAST::Union{Expr,Symbol,Nothing}, buildOption = <buildOption>)
 ```
 
-The`buildCode` is merged to the corresponding `<subModel>` in the calling environment.
+A new `updatedSubmodel` is generated from `submodel` merged with additional code and then returned.
 The arguments of `<buildFunction>`are:
 
-- `subModel`: The returned `buildCode` is merged to `submodel`
+- `updatedSubmodel`: A potentially new reference to the updated `submodel`
 - `FloatType`, `TimeType`: Types used when instantiating `SimulationModel{FloatType,TimeType}`
 - `unitless`: Argument `unitless` of `@instantiateModel`.
-- `modelPath`: Path upto `<subModel>`, such as: `:( a.b.c )`.
-- `buildDict`: Dictionary, that will be stored in the corresponding SimulationModel instance and
-               that allows to store information about the build-process,
-               typically with key `string(modelPath)` (if modelPath==Nothing, key="" is used).
+- `ID`: Unique ID to identify the generated submodel (to be used in the code merged into the submodel)
+- `pathAST`: Path upto `<submodel>` as Abstract Syntax Tree, such as: `:( a.b.c )`
+             (this path might be used as part of a variable name in the code merged into the submodel).
 - `buildOption`: Option used for the generation of `buildCode`.
 
-Note, keys `_buildFunction` and `_buildOption` are deleted from the corresponding `<subModel>`.
+Note, keys `_buildFunction` and `_buildOption` have been deleted in the returned `updatedSubmodel`.
 """
-function buildSubModels!(model::AbstractDict, modelModule, FloatType::Type, TimeType::Type, unitless::Bool,
-                         buildDict::OrderedDict{String,Any}; path::Union{Expr,Symbol,Nothing}=nothing)
+function buildSubmodels!(model::AbstractDict, modelModule, FloatType::Type, TimeType::Type, unitless::Bool,
+                         buildDict::OrderedDict{String,Any}; pathAST::Union{Expr,Symbol,Nothing}=nothing)
     if haskey(model, :_buildFunction)
         _buildFunction = model[:_buildFunction]
         if haskey(_buildFunction, :functionName)
             buildFunction = _buildFunction[:functionName]
         else
-            @error "Model $path has key :_buildFunction but its value has no key :functionName"
+            @error "Model $pathAST has key :_buildFunction but its value has no key :functionName"
         end        
         delete!(model, :_buildFunction)
-        quotedPath = Meta.quot(path)
+        ID = modelPathAsString(pathAST)        
+        quotedPathAST = Meta.quot(pathAST)
         if haskey(model, :_buildOption)
             buildOption = model[:_buildOption]
             delete!(model, :_buildOption)
-            buildCode = Core.eval(modelModule, :($buildFunction($model, $FloatType, $TimeType, $unitless, $buildDict, $quotedPath, buildOption=$buildOption)) )
+            (model, instantiatedSubmodelStruct) = Core.eval(modelModule, :($buildFunction($model, $FloatType, $TimeType, $unitless, $ID, $quotedPathAST, buildOption=$buildOption)) )
         else
-            buildCode = Core.eval(modelModule, :($buildFunction($model, $FloatType, $TimeType, $unitless, $buildDict, $quotedPath)))
+            (model, instantiatedSubmodelStruct) = Core.eval(modelModule, :($buildFunction($model, $FloatType, $TimeType, $unitless, $ID, $quotedPathAST)))
         end
-        return  model | buildCode
+        buildDict[ID] = instantiatedSubmodelStruct
+        return model
     end
 
     for (key,value) in model
         if typeof(value) <: OrderedDict && haskey(value, :_class) && value[:_class] == :Model
-            model[key] = buildSubModels!(value, modelModule, FloatType, TimeType, unitless, buildDict; path=appendSymbol(path,key))
+            model[key] = buildSubmodels!(value, modelModule, FloatType, TimeType, unitless, buildDict; pathAST=appendSymbol(pathAST,key))
         end
     end
     return model
@@ -959,7 +958,7 @@ function instantiateModel(model; modelName="", modelModule=nothing, source=nothi
                           FloatType <: MonteCarloMeasurements.AbstractParticles;
                           baseType(FloatType) else FloatType end  # baseType(..) is defined in CodeGeneration.jl
             model = deepcopy(model)
-            model = buildSubModels!(model, modelModule, FloatType, TimeType, unitless, buildDict)
+            model = buildSubmodels!(model, modelModule, FloatType, TimeType, unitless, buildDict)
 
             if logModel
                 @showModel(model)

test/TestHeatTransfer2.jl

@@ -13,7 +13,7 @@ HeatedRod2 = Model(
 )
 
 # Model with unit
-heatedRod2a = @instantiateModel(HeatedRod2, logCode=false, unitless=true)
+heatedRod2a = @instantiateModel(HeatedRod2, logCode=false, unitless=false)
 simulate!(heatedRod2a, stopTime = 1e5, log=true, merge=Map(rod = Map(nT=8)), logParameters=true, logEvaluatedParameters=true)
 showInfo(heatedRod2a)