thummeto / fmicore.jl Goto Github PK

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

When you call your loaded fmu with different arguments for y_refs in a sequence (first call with y_refs, second without y_refs), an assert is thrown claiming that the lenghts of y_refs and y should be equal.
The first call enters the if-condition (if length(y_refs)>0) and allocates the c.default_y and sets y equal to it. The second does not enter this condition, hence does not re-allocate c.default_y, but then compares y (the old y=c.default_y!?) to the new y_refs' length.
Since y is used again later (e.g. in 274) if length(y)>0, it should be allocated in every call correctly, i.e.

1. y_refs exists, y exist <- check lengths, assert if unequal
2. y_refs exist, no y in arguments <- allocate y with length of y_refs
3. no y_refs, but y <-assert that no y_refs is there, that is basically 1.
4. no y_refs, no y <- allocate y with length zero, i.e. like 2.

So what about:

if length(y) > 0
    @assert (length(y) == length(y_refs)) "Length of `y` must match length of `y_refs`."
else
    y = zeros(fmi2Real, length(y_refs))
    if length(y_refs)>0
        logInfo(c.fmu, "Automatically allocated `y` for given `y_refs`")
    end 
end

I have to admit, I didn't get the point of having default_y, so my proposal might be nonsense.
Here's a minimal example:

using FMI
using FMI:fmi2ValueReference
using FMIZoo

tSave = 0.0:0.01:8.0
fmu = fmiLoad("SpringPendulumExtForce1D", "Dymola", "2022x"; type=:ME) 
fmiSimulate(fmu,(tStart,tStop)) #<-you need this (or something smarter) to generate a fmu-component before calling the fmu below. That's another bug in my opinion.

outputVRs = UInt32[]
for vr in fmu.modelDescription.outputValueReferences
    push!(outputVRs, vr)
end

#1st call, with y_refs
fmu(;y_refs=outputVRs)

#2nd call, w/o y_refs -> assert
fmu()

#workaround...
length(fmu.components[1].default_y)
fmu.components[1].default_y=zeros(fmi2Real,0)
fmu()

Base.getindex is called when the input arguments are an FMU2EvaluationOutput (out) and anything but not a CartesianIndex{A}.
In the example below, ind is a vector of indices.

Minimal example

import FMI: Base.getindex
fmi = fmiLoad("SpringPendulumExtForce1D", "Dymola", "2022x"; type=:ME)
fmiSimulate(fmi) #<-since no FMU2Component allocated <-and I will make a ticket rightaway for that.
Base.getindex(fmu(;dx_refs=:all),[1,2])

You need this when you want to make a Flux.Chain which uses a substet of the FMU-derivatives, e.g.

inputN = [2,9,10,12,17,24,25]
net = Chain(x -> myFMU(; x=x,dx_refs=:all),
            dx -> cache(dx),                     
            dx -> dx[inputN],
		…)

There is a workaround (if you only have dx-Output): One can use myFMU(...).dx as output of the first layer.

Proposed solution!?
Dispatch for ind::AbstractVector{<:Integer}
If that's okay for you, I can make a draft.

When you call the fmu without having it simulated first, you get an assert that no FMU2Component is allocated.

fmi = fmiLoad("SpringPendulumExtForce1D", "Dymola", "2022x"; type=:ME)
fmu()

The description in eval.jl says that if no component is allocated, a component will by allocated. Hence I wonder if this used to work in the past but not anymore, further if there is a good reason why you are not allocating it, and finally: if there is a good reason for not allocating, I would wish for a more meaningful explanation for non-FMU-component-structure-experts (e.g. "Please call fmiInstantiate to allocate a component." <-I don't know what is actually the shortest/most reasonable way to get one).
If there is no good reason to not create one in the eval-function, this should be added.
Happy to discuss (and to learn).

General review round to fix types where possible...