Core.UnionMethod
(str::Union{fmi2Struct, fmi3Struct})(; t::Tuple{Float64, Float64}, kwargs...)

Wrapper for dispatch to fmiSimulate.

FMI.fmi2GetBooleanStatusMethod
fmi2GetBooleanStatus(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetBooleanStatus!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMI.fmi2GetIntegerStatusMethod
fmi2GetIntegerStatus(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetIntegerStatus!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMI.fmi2GetRealStatusMethod
fmi2GetRealStatus(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetRealStatus!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMI.fmi2GetStatusMethod
fmi2GetStatus(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetStatus!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMI.fmi2GetStringStatusMethod
fmi2GetStringStatus(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetStringStatus!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMI.fmi2InfoMethod
 fmi2Info(fmu::FMU2)

Print information about the fmu.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.22]: 2.1.4 Inquire Platform and Version Number of Header Files
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions
FMI.fmi2SampleDirectionalDerivative!Method
fmi2SampleDirectionalDerivative!(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SampleDirectionalDerivative!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMI.fmi2SampleDirectionalDerivativeMethod
fmi2SampleDirectionalDerivative(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SampleDirectionalDerivative(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMI.fmi2SimulateFunction
fmi2Simulate(args...)

Starts a simulation of the FMU2 for the matching type (fmi2SimulateCS(args...) or fmi2SimulateME(args...)); if both types are available, CS is preferred.

See also fmi2SimulateCS, fmi2SimulateME.

FMI.fmi2SimulateFunction
fmi2Simulate(c::FMU2Component, tspan::Union{Tuple{Float64, Float64}, Nothing}=nothing; kwargs...)

Wrapper for fmi2Simulate(fmu::FMU2, c::Union{FMU2Component, Nothing}, tspan::Union{Tuple{Float64, Float64}, Nothing}=nothing; kwargs...) without a provided FMU2. (FMU2 fmu is taken from c)

FMI.fmi2SimulateMethod
fmi2Simulate(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2Simulate(fmu::FMU2, c::Union{FMU2Component, Nothing}, args...; kwargs...) without a provided FMU2Component. (Component c gets passed as nothing)

FMI.fmi2SimulateCSFunction
fmi2SimulateCS(fmu::FMU2, 
            c::Union{FMU2Component, Nothing}=nothing, 
            tspan::Union{Tuple{Float64, Float64}, Nothing}=nothing;
            [tolerance::Union{Real, Nothing} = nothing,
            dt::Union{Real, Nothing} = nothing,
            recordValues::fmi2ValueReferenceFormat = nothing,
            saveat = [],
            setup::Union{Bool, Nothing} = nothing,
            reset::Union{Bool, Nothing} = nothing,
            instantiate::Union{Bool, Nothing} = nothing,
            freeInstance::Union{Bool, Nothing} = nothing,
            terminate::Union{Bool, Nothing} = nothing,
            inputValueReferences::fmi2ValueReferenceFormat = nothing,
            inputFunction = nothing,
            showProgress::Bool=true,
            parameters::Union{Dict{<:Any, <:Any}, Nothing} = nothing])

Simulate CS-FMU for the given simulation time interval.

Arguments

  • fmu::FMU2: Mutable struct representing a FMU and all it instantiated instances.

  • c::Union{FMU2Component, Nothing}=nothing: Mutable struct representing an instantiated instance of a FMU.

  • tspan::Union{Tuple{Float64, Float64}, Nothing}=nothing: Simulation-time-span as tuple (default = nothing: use default value from fmu's model description or (0.0, 1.0))

  • tolerance::Union{Real, Nothing} = nothing: tolerance for the solver (default = nothing: use default value from fmu's model description or 0.0)

  • dt::Union{Real, Nothing} = nothing: stepszie for the solver (default = nothing: use default value from fmu's model description or 1e-3)

  • recordValues::fmi2ValueReferenceFormat = nothing: Array of variables (Strings or variableIdentifiers) to record. Results are returned as DiffEqCallbacks.SavedValues

  • saveat = nothing: Time points to save values at (default = nothing: save at each communication timestep)

  • setup::Union{Bool, Nothing} = nothing: call fmi2SetupExperiment, fmi2EnterInitializationMode and fmi2ExitInitializationMode before each step (default = nothing: use value from fmu's FMU2ExecutionConfiguration)

  • reset::Union{Bool, Nothing} = nothing: call fmi2Reset before each step (default = nothing: use value from fmu's FMU2ExecutionConfiguration)

  • instantiate::Union{Bool, Nothing} = nothing: call fmi2Reset before each step (default = nothing: use value from fmu's FMU2ExecutionConfiguration)

  • freeInstance::Union{Bool, Nothing} = nothing: call fmi2FreeInstance after each step (default = nothing: use value from fmu's FMU2ExecutionConfiguration)

  • terminate::Union{Bool, Nothing} = nothing: call fmi2Terminate after each step (default = nothing: use value from fmu's FMU2ExecutionConfiguration)

  • inputValueReferences::fmi2ValueReferenceFormat = nothing: Input variables (Strings or variableIdentifiers) to set at each communication step

  • inputFunction = nothing: Function to get values for the input variables at each communication step.

    Pattern [c: current component, t: current time, returning array of values to be passed to fmi2SetReal(..., inputValueReferences, inputFunction(...))]:

    • inputFunction(t::fmi2Real)
    • inputFunction(c::FMU2Component, t::fmi2Real)
  • showProgress::Bool = true: print simulation progressmeter in REPL

  • parameters::Union{Dict{<:Any, <:Any}, Nothing} = nothing: Dict of parameter variables (strings or variableIdentifiers) and values (Real, Integer, Boolean, String) to set parameters during initialization

Returns:

  • fmusol::FMU2Solution, containing bool fmusol.success and if keyword recordValues is set, the saved values as fmusol.values.

See also fmi2Simulate, fmi2SimulateME.

FMI.fmi2SimulateCSFunction
fmi2SimulateCS(c::FMU2Component, tspan::Union{Tuple{Float64, Float64}, Nothing}=nothing; kwargs...)

Wrapper for fmi2SimulateCS(fmu::FMU2, c::Union{FMU2Component, Nothing}, tspan::Union{Tuple{Float64, Float64}, Nothing}=nothing; kwargs...) without a provided FMU2. (FMU2 fmu is taken from c)

FMI.fmi2SimulateCSMethod
fmi2SimulateCS(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SimulateCS(fmu::FMU2, c::Union{FMU2Component, Nothing}, args...; kwargs...) without a provided FMU2Component. (Component c gets passed as nothing)

FMI.fmi2SimulateMEFunction
fmi2SimulateME(fmu::FMU2, 
            c::Union{FMU2Component, Nothing}=nothing, 
            tspan::Union{Tuple{Float64, Float64}, Nothing}=nothing;
            [tolerance::Union{Real, Nothing} = nothing,
            dt::Union{Real, Nothing} = nothing,
            solver = nothing,
            customFx = nothing,
            recordValues::fmi2ValueReferenceFormat = nothing,
            recordEventIndicators::Union{AbstractArray{<:Integer, 1}, UnitRange{<:Integer}, Nothing} = nothing,
            recordEigenvalues::Bool=false,
            saveat = nothing,
            x0::Union{AbstractArray{<:Real}, Nothing} = nothing,
            setup::Union{Bool, Nothing} = nothing,
            reset::Union{Bool, Nothing} = nothing,
            instantiate::Union{Bool, Nothing} = nothing,
            freeInstance::Union{Bool, Nothing} = nothing,
            terminate::Union{Bool, Nothing} = nothing,
            inputValueReferences::fmi2ValueReferenceFormat = nothing,
            inputFunction = nothing,
            parameters::Union{Dict{<:Any, <:Any}, Nothing} = nothing,
            dtmax::Union{Real, Nothing} = nothing,
            callbacksBefore = [],
            callbacksAfter = [],
            showProgress::Bool = true,
            kwargs...])

Simulate ME-FMU for the given simulation time interval.

State- and Time-Events are handled correctly.

Arguments

  • fmu::FMU2: Mutable struct representing a FMU and all it instantiated instances.

  • c::Union{FMU2Component, Nothing}=nothing: Mutable struct representing an instantiated instance of a FMU.

  • tspan::Union{Tuple{Float64, Float64}, Nothing}=nothing: Simulation-time-span as tuple (default = nothing: use default value from fmu's model description or (0.0, 1.0))

  • tolerance::Union{Real, Nothing} = nothing: tolerance for the solver (default = nothing: use default value from fmu's model description or -if not available- default from DifferentialEquations.jl)

  • dt::Union{Real, Nothing} = nothing: stepszie for the solver (default = nothing: use default value from fmu's model description or -if not available- default from DifferentialEquations.jl)

  • solver = nothing: Any Julia-supported ODE-solver (default = nothing: use DifferentialEquations.jl default solver)

  • customFx: [deprecated] custom state derivative function ẋ=f(x,t)

  • recordValues::fmi2ValueReferenceFormat = nothing: Array of variables (Strings or variableIdentifiers) to record. Results are returned as DiffEqCallbacks.SavedValues

  • recordEventIndicators::Union{AbstractArray{<:Integer, 1}, UnitRange{<:Integer}, Nothing} = nothing: Array or Range of event indicators to record

  • recordEigenvalues::Bool=false: compute and record eigenvalues

  • saveat = nothing: Time points to save (interpolated) values at (default = nothing: save at each solver timestep)

  • x0::Union{AbstractArray{<:Real}, Nothing} = nothing: inital fmu State (default = nothing: use current or default-inital fmu state)

  • setup::Union{Bool, Nothing} = nothing: call fmi2SetupExperiment, fmi2EnterInitializationMode and fmi2ExitInitializationMode before each step (default = nothing: use value from fmu's FMU2ExecutionConfiguration)

  • reset::Union{Bool, Nothing} = nothing: call fmi2Reset before each step (default = nothing: use value from fmu's FMU2ExecutionConfiguration)

  • instantiate::Union{Bool, Nothing} = nothing: call fmi2Instantiate! before each step (default = nothing: use value from fmu's FMU2ExecutionConfiguration)

  • freeInstance::Union{Bool, Nothing} = nothing: call fmi2FreeInstance after each step (default = nothing: use value from fmu's FMU2ExecutionConfiguration)

  • terminate::Union{Bool, Nothing} = nothing: call fmi2Terminate after each step (default = nothing: use value from fmu's FMU2ExecutionConfiguration)

  • inputValueReferences::fmi2ValueReferenceFormat = nothing: Input variables (Strings or variableIdentifiers) to set at each simulation step

  • inputFunction = nothing: Function to get values for the input variables at each simulation step.

    Pattern [c: current component, u: current state ,t: current time, returning array of values to be passed to fmi2SetReal(..., inputValueReferences, inputFunction(...))]:

    • inputFunction(t::fmi2Real)
    • inputFunction(c::FMU2Component, t::fmi2Real)
    • inputFunction(c::FMU2Component, u::Union{AbstractArray{fmi2Real,1}, Nothing})
    • inputFunction(u::Union{AbstractArray{fmi2Real,1}, Nothing}, t::fmi2Real)
    • inputFunction(c::FMU2Component, u::Union{AbstractArray{fmi2Real,1}, Nothing}, t::fmi2Real)
  • parameters::Union{Dict{<:Any, <:Any}, Nothing} = nothing: Dict of parameter variables (strings or variableIdentifiers) and values (Real, Integer, Boolean, String) to set parameters during initialization

  • dtmax::Union{Real, Nothing} = nothing: sets the maximum stepszie for the solver (default = nothing: use (Simulation-time-span-length)/100.0)

  • callbacksBefore = [], callbacksAfter = []: functions that are to be called before and after internal time-event-, state-event- and step-event-callbacks are called

  • showProgress::Bool = true: print simulation progressmeter in REPL

  • kwargs...: keyword arguments that get passed onto the solvers solve call

Returns:

  • If keyword recordValues has value nothing, a struct of type ODESolution.
  • If keyword recordValues is set, a tuple of type (ODESolution, DiffEqCallbacks.SavedValues).

See also fmi2Simulate, fmi2SimulateCS.

FMI.fmi2SimulateMEFunction
fmi2SimulateME(c::FMU2Component, tspan::Union{Tuple{Float64, Float64}, Nothing}=nothing; kwargs...)

Wrapper for fmi2SimulateME(fmu::FMU2, c::Union{FMU2Component, Nothing}, tspan::Union{Tuple{Float64, Float64}, Nothing}=nothing; kwargs...) without a provided FMU2. (FMU2 fmu is taken from c)

FMI.fmi2SimulateMEMethod
fmi2SimulateME(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SimulateME(fmu::FMU2, c::Union{FMU2Component, Nothing}, args...; kwargs...) without a provided FMU2Component. (Component c gets passed as nothing)

FMI.fmi2VariableDependsOnVariableMethod
fmi2VariableDependsOnVariable(fmu::FMU2, vr1::fmi2ValueReference, vr2::fmi2ValueReference)

Return the dependence of the variable described by vr1 on another variable described by vr2 based on the model description of the fmu.

See also fmi2GetDependencies.

FMI.fmi3GetNumberOfVariableDependenciesMethod
fmi3GetNumberOfVariableDependencies(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetNumberOfVariableDependencies(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMI.fmi3GetOutputDerivativesMethod
fmi3GetOutputDerivatives(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetOutputDerivatives(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMI.fmi3GetVariableDependenciesMethod
fmi3GetVariableDependencies(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetVariableDependencies(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMI.fmi3InfoMethod
 fmi3Info(fmu::FMU3)

Print information about the fmu.

FMI.fmi3SimulateFunction
fmi3Simulate(args...)

Starts a simulation of the FMU3 for the matching type (fmi3SimulateCS(args...), fmi3SimulateME(args...) or fmi3SimulateSE(args...)); if multiple types are available, CS is preferred over ME, over SE.

See also fmi3SimulateCS, fmi3SimulateME, fmi3SimulateSE.

FMI.fmi3SimulateFunction
fmi3Simulate(c::FMU3Instance, t_start::Union{Real, Nothing} = nothing, t_stop::Union{Real, Nothing} = nothing; kwargs...)

Wrapper for fmi3Simulate(fmu::FMU3, c::Union{FMU3Instance, Nothing}=nothing, t_start::Union{Real, Nothing} = nothing, t_stop::Union{Real, Nothing} = nothing; kwargs...) without a provided FMU3. (FMU3 fmu is taken from c)

FMI.fmi3SimulateMethod
fmi3Simulate(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3Simulate(fmu::FMU3, c::Union{FMU3Instance, Nothing}, args...; kwargs...) without a provided FMU3Instance. (Instance c gets passed as nothing)

FMI.fmi3SimulateCSFunction
fmi3SimulateCS(fmu::FMU3, 
            c::Union{FMU3Instance, Nothing}=nothing, 
            t_start::Union{Real, Nothing} = nothing, 
            t_stop::Union{Real, Nothing} = nothing;
            [tolerance::Union{Real, Nothing} = nothing,
            dt::Union{Real, Nothing} = nothing,
            recordValues::fmi3ValueReferenceFormat = nothing,
            saveat = [],
            setup::Union{Bool, Nothing} = nothing,
            reset::Union{Bool, Nothing} = nothing,
            instantiate::Union{Bool, Nothing} = nothing,
            freeInstance::Union{Bool, Nothing} = nothing,
            terminate::Union{Bool, Nothing} = nothing,
            inputValueReferences::fmi3ValueReferenceFormat = nothing,
            inputFunction = nothing,
            showProgress::Bool=true,
            parameters::Union{Dict{<:Any, <:Any}, Nothing} = nothing])

Simulate CS-FMU for the given simulation time interval.

Arguments

  • fmu::FMU3: Mutable struct representing a FMU and all it instantiated instances.

  • c::Union{FMU3Instance, Nothing}=nothing: Mutable struct representing an instantiated instance of a FMU.

  • t_start::Union{Real, Nothing} = nothing: Simulation-time-span start time (default = nothing: use default value from fmu's model description or 0.0)

  • t_stop::Union{Real, Nothing} = nothing: Simulation-time-span stop time (default = nothing: use default value from fmu's model description or 1.0)

  • tolerance::Union{Real, Nothing} = nothing: tolerance for the solver (default = nothing: use default value from fmu's model description or 0.0)

  • dt::Union{Real, Nothing} = nothing: stepszie for the solver (default = nothing: use default value from fmu's model description or 1e-3)

  • solver = nothing: Any Julia-supported ODE-solver (default = nothing: use DifferentialEquations.jl default solver)

  • recordValues::fmi3ValueReferenceFormat = nothing: Array of variables (Strings or variableIdentifiers) to record. Results are returned as DiffEqCallbacks.SavedValues

  • saveat = nothing: Time points to save values at (default = nothing: save at each communication timestep)

  • setup::Union{Bool, Nothing} = nothing: call fmi3EnterInitializationMode and fmi3ExitInitializationMode before each step (default = nothing: use value from fmu's FMU3ExecutionConfiguration)

  • reset::Union{Bool, Nothing} = nothing: call fmi3Reset before each step (default = nothing: use value from fmu's FMU3ExecutionConfiguration)

  • instantiate::Union{Bool, Nothing} = nothing: call fmi3Instantiate<FMU-Type>! before each step (default = nothing: use value from fmu's FMU3ExecutionConfiguration)

  • freeInstance::Union{Bool, Nothing} = nothing: call fmi3FreeInstance after each step (default = nothing: use value from fmu's FMU3ExecutionConfiguration)

  • terminate::Union{Bool, Nothing} = nothing: call fmi3Terminate after each step (default = nothing: use value from fmu's FMU3ExecutionConfiguration)

  • inputValueReferences::fmi3ValueReferenceFormat = nothing: Input variables (Strings or variableIdentifiers) to set at each communication step

  • inputFunction = nothing: Function to get values for the input variables at each communication step.

    Pattern [c: current instance, t: current time, returning array of values to be passed to fmi3SetFloat64(..., inputValueReferences, inputFunction(...))]:

    • inputFunction(t::fmi3Float64)
    • inputFunction(c::FMU3Instance, t::fmi3Float64)
  • showProgress::Bool = true: print simulation progressmeter in REPL

  • parameters::Union{Dict{<:Any, <:Any}, Nothing} = nothing: Dict of parameter variables (strings or variableIdentifiers) and values (Boolean, String, Float64, ...) to set parameters during initialization

Returns:

  • fmusol::FMU3Solution, containing bool fmusol.success and if keyword recordValues is set, the saved values as fmusol.values.

See also fmi3Simulate, fmi3SimulateME, fmi3SimulateSE.

FMI.fmi3SimulateCSFunction
fmi3SimulateCS(c::FMU3Instance, t_start::Union{Real, Nothing} = nothing, t_stop::Union{Real, Nothing} = nothing; kwargs...)

Wrapper for fmi3SimulateCS(fmu::FMU3, c::Union{FMU3Instance, Nothing}=nothing, t_start::Union{Real, Nothing} = nothing, t_stop::Union{Real, Nothing} = nothing; kwargs...) without a provided FMU3. (FMU3 fmu is taken from c)

FMI.fmi3SimulateCSMethod
fmi3SimulateCS(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SimulateCS(fmu::FMU3, c::Union{FMU3Instance, Nothing}, args...; kwargs...) without a provided FMU3Instance. (Instance c gets passed as nothing)

FMI.fmi3SimulateMEFunction
fmi3SimulateME(fmu::FMU3, 
            c::Union{FMU3Instance, Nothing}=nothing, 
            t_start::Union{Real, Nothing} = nothing, 
            t_stop::Union{Real, Nothing} = nothing;
            [tolerance::Union{Real, Nothing} = nothing,
            dt::Union{Real, Nothing} = nothing,
            solver = nothing,
            customFx = nothing,
            recordValues::fmi3ValueReferenceFormat = nothing,
            saveat = nothing,
            x0::Union{AbstractArray{<:Real}, Nothing} = nothing,
            setup::Union{Bool, Nothing} = nothing,
            reset::Union{Bool, Nothing} = nothing,
            instantiate::Union{Bool, Nothing} = nothing,
            freeInstance::Union{Bool, Nothing} = nothing,
            terminate::Union{Bool, Nothing} = nothing,
            inputValueReferences::fmi3ValueReferenceFormat = nothing,
            inputFunction = nothing,
            parameters::Union{Dict{<:Any, <:Any}, Nothing} = nothing,
            dtmax::Union{Real, Nothing} = nothing,
            callbacks = [],
            showProgress::Bool = true,
            kwargs...])

Simulate ME-FMU for the given simulation time interval.

State- and Time-Events are handled correctly.

Arguments

  • fmu::FMU3: Mutable struct representing a FMU and all it instantiated instances.

  • c::Union{FMU3Instance, Nothing}=nothing: Mutable struct representing an instantiated instance of a FMU.

  • t_start::Union{Real, Nothing} = nothing: Simulation-time-span start time (default = nothing: use default value from fmu's model description or 0.0)

  • t_stop::Union{Real, Nothing} = nothing: Simulation-time-span stop time (default = nothing: use default value from fmu's model description or 1.0)

  • tolerance::Union{Real, Nothing} = nothing: tolerance for the solver (default = nothing: use default value from fmu's model description or -if not available- default from DifferentialEquations.jl)

  • dt::Union{Real, Nothing} = nothing: stepszie for the solver (default = nothing: use default value from fmu's model description or -if not available- default from DifferentialEquations.jl)

  • solver = nothing: Any Julia-supported ODE-solver (default = nothing: use DifferentialEquations.jl default solver)

  • customFx: [deprecated] custom state derivative function ẋ=f(x,t)

  • recordValues::fmi3ValueReferenceFormat = nothing: Array of variables (Strings or variableIdentifiers) to record. Results are returned as DiffEqCallbacks.SavedValues

  • saveat = nothing: Time points to save (interpolated) values at (default = nothing: save at each solver timestep)

  • x0::Union{AbstractArray{<:Real}, Nothing} = nothing: inital fmu State (default = nothing: use current or default-inital fmu state)

  • setup::Union{Bool, Nothing} = nothing: call fmi3EnterInitializationMode and fmi3ExitInitializationMode before each step (default = nothing: use value from fmu's FMU3ExecutionConfiguration)

  • reset::Union{Bool, Nothing} = nothing: call fmi3Reset before each step (default = nothing: use value from fmu's FMU3ExecutionConfiguration)

  • instantiate::Union{Bool, Nothing} = nothing: call fmi3Instantiate<FMU-Type>! before each step (default = nothing: use value from fmu's FMU3ExecutionConfiguration)

  • freeInstance::Union{Bool, Nothing} = nothing: call fmi3FreeInstance after each step (default = nothing: use value from fmu's FMU3ExecutionConfiguration)

  • terminate::Union{Bool, Nothing} = nothing: call fmi3Terminate after each step (default = nothing: use value from fmu's FMU3ExecutionConfiguration)

  • inputValueReferences::fmi3ValueReferenceFormat = nothing: Input variables (Strings or variableIdentifiers) to set at each simulation step

  • inputFunction = nothing: Function to get values for the input variables at each simulation step.

    Pattern [c: current instance, u: current state ,t: current time, returning array of values to be passed to fmi3SetFloat64(..., inputValueReferences, inputFunction(...))]:

    • inputFunction(t::fmi3Float64)
    • inputFunction(c::FMU3Instance, t::fmi3Float64)
    • inputFunction(c::FMU3Instance, u::Union{AbstractArray{fmi3Float64,1}, Nothing})
    • inputFunction(u::Union{AbstractArray{fmi3Float64,1}, Nothing}, t::fmi3Float64)
    • inputFunction(c::FMU3Instance, u::Union{AbstractArray{fmi3Float64,1}, Nothing}, t::fmi3Float64)
  • parameters::Union{Dict{<:Any, <:Any}, Nothing} = nothing: Dict of parameter variables (strings or variableIdentifiers) and values (Real, Integer, Boolean, String) to set parameters during initialization

  • dtmax::Union{Real, Nothing} = nothing: sets the maximum stepszie for the solver (default = nothing: use (Simulation-time-span-length)/100.0)

  • callbacks = []: functions that are to be called at each solver time step

  • showProgress::Bool = true: print simulation progressmeter in REPL

  • kwargs...: keyword arguments that get passed onto the solvers solve call

Returns:

  • If keyword recordValues has value nothing, a struct of type ODESolution.
  • If keyword recordValues is set, a tuple of type (ODESolution, DiffEqCallbacks.SavedValues).

See also fmi3Simulate, fmi3SimulateCS, fmi3SimulateSE.

FMI.fmi3SimulateMEFunction
fmi3SimulateME(c::FMU3Instance, t_start::Union{Real, Nothing} = nothing, t_stop::Union{Real, Nothing} = nothing; kwargs...)

Wrapper for fmi3SimulateME(fmu::FMU3, c::Union{FMU3Instance, Nothing}, t_start::Union{Real, Nothing} = nothing, t_stop::Union{Real, Nothing} = nothing; kwargs...) without a provided FMU3. (FMU3 fmu is taken from c)

FMI.fmi3SimulateMEMethod
fmi3SimulateME(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SimulateME(fmu::FMU3, c::Union{FMU3Instance, Nothing}, args...; kwargs...) without a provided FMU3Instance. (Instance c gets passed as nothing)

FMI.fmi3SimulateSEFunction
fmi3SimulateSE(fmu::FMU3, 
            c::Union{FMU3Instance, Nothing}=nothing, 
            t_start::Union{Real, Nothing} = nothing, 
            t_stop::Union{Real, Nothing} = nothing;
            [tolerance::Union{Real, Nothing} = nothing,
            dt::Union{Real, Nothing} = nothing,
            recordValues::fmi3ValueReferenceFormat = nothing,
            saveat = [],
            setup::Union{Bool, Nothing} = nothing,
            reset::Union{Bool, Nothing} = nothing,
            instantiate::Union{Bool, Nothing} = nothing,
            freeInstance::Union{Bool, Nothing} = nothing,
            terminate::Union{Bool, Nothing} = nothing,
            inputValueReferences::fmi3ValueReferenceFormat = nothing,
            inputFunction = nothing,
            showProgress::Bool=true,
            parameters::Union{Dict{<:Any, <:Any}, Nothing} = nothing])

Simulate SE-FMU; not yet implemented in library

See also fmi3Simulate, fmi3SimulateME, fmi3SimulateCS.

FMI.fmi3VariableDependsOnVariableMethod
fmi3VariableDependsOnVariable(fmu::FMU3, vr1::fmi3ValueReference, vr2::fmi3ValueReference)

Return the dependence of the variable described by vr1 on another variable described by vr2 based on the model description of the fmu.

See also fmi3GetDependencies.

FMI.fmiCanGetSetStateMethod
fmiCanGetSetState(str::Union{fmi2StructMD, fmi3StructMD})

Returns true, if the FMU supports the getting/setting of states

Arguments

More detailed: fmi2StructMD = Union{FMU2, FMU2Component, fmi2ModelDescription} More detailed: fmi3StructMD = Union{FMU3, FMU3Instance, fmi3ModelDescription}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • str::fmi2ModelDescription: Struct witch provides the static information of ModelVariables.
  • str::FMU3: Mutable struct representing an FMU in the FMI 3.0 Standard.
  • str::FMU3Instance: Mutable struct represents a pointer to an FMU specific data structure that contains the information needed. Also in FMI 3.0 Standard.
  • str::fmi3ModelDescription: Struct witch provides the static information of ModelVariables.

Returns

  • ::Bool: The function fmi2CanGetSetState returns True, if the FMU supports the getting/setting of states.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.22]: 2.1.4 Inquire Platform and Version Number of Header Files
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions

See also fmi2CanGetSetState, fmi2StructMD, FMU2, FMU2Component, fmi2ModelDescription, fmi3CanGetSetState, fmi3StructMD, FMU3, FMU3Instance, fmi3ModelDescription.

FMI.fmiCanSerializeFMUstateMethod
fmiCanSerializeFMUstate(str::Union{fmi2StructMD, fmi3StructMD})

Returns true, if the FMU state can be serialized

Arguments

More detailed: fmi2StructMD = Union{FMU2, FMU2Component, fmi2ModelDescription} More detailed: fmi3StructMD = Union{FMU3, FMU3Instance, fmi3ModelDescription}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • str::fmi2ModelDescription: Struct wich provides the static information of ModelVariables.
  • str::FMU3: Mutable struct representing an FMU in the FMI 3.0 Standard.
  • str::FMU3Instance: Mutable struct represents a pointer to an FMU specific data structure that contains the information needed. Also in FMI 3.0 Standard.
  • str::fmi3ModelDescription: Struct witch provides the static information of ModelVariables.

Returns

  • ::Bool: The function fmi2CanSerializeFMUstate returns True, if the FMU state can be serialized.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.22]: 2.1.4 Inquire Platform and Version Number of Header Files
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions

See also fmi2CanSerializeFMUstate, fmi2StructMD, FMU2, FMU2Component, fmi2ModelDescription, fmi3CanSerializeFMUstate, fmi3StructMD, FMU3, FMU3Instance, fmi3ModelDescription.

FMI.fmiCompletedIntegratorStepMethod

DEPRECATED fmiCompletedIntegratorStep(str::fmi2Struct, c::FMU2Component, noSetFMUStatePriorToCurrentPoint::fmi2Boolean)

This function must be called by the environment after every completed step

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • noSetFMUStatePriorToCurrentPoint::fmi2Boolean: Argument noSetFMUStatePriorToCurrentPoint = fmi2True if fmi2SetFMUState will no longer be called for time instants prior to current time in this simulation run.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously
  • enterEventMode::Array{fmi2Boolean, 1}: Returns enterEventMode[1] to signal to the environment if the FMU shall call fmi2EnterEventMode
  • terminateSimulation::Array{fmi2Boolean, 1}: Returns terminateSimulation[1] to signal if the simulation shall be terminated.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.83]: 3.2.2 Evaluation of Model Equations
FMI.fmiDeSerializeFMUstateMethod

DEPRECATEDTODO fmiDeSerializeFMUstate(str::fmi2Struct, c::FMU2Component, serializedState::Array{fmi2Byte})

Deserialize the data in the serializedState fmi2Byte field

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • serializedState::Array{fmi2Byte}: Argument serializedState contains the fmi2Byte field to be deserialized.

Returns

  • Return state is a pointer to a copy of the internal FMU state.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.25]: 2.1.8 Getting and Setting the Complete FMU State
FMI.fmiDoStepMethod

DEPRECATED fmiDoStep(str::fmi2Struct, c::FMU2Component, communicationStepSize::Union{Real, Nothing} = nothing; currentCommunicationPoint::Union{Real, Nothing} = nothing, noSetFMUStatePriorToCurrentPoint::Bool = true)

fmiDoStep(str::fmi2Struct, c::FMU2Component, currentCommunicationPoint::fmi2Real, communicationStepSize::fmi2Real, noSetFMUStatePriorToCurrentPoint::fmi2Boolean)

Does one step in the CoSimulation FMU

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • communicationStepSize::Union{Real, Nothing} = nothing: Argument communicationStepSize contains a value of type Real or Nothing , if no argument is passed the default value nothing is used. communicationStepSize defines the communiction step size.
  • currentCommunicationPoint::fmi2Real: Argument currentCommunicationPoint contains a value of type fmi2Real which is a identifier for a variable value . currentCommunicationPoint defines the current communication point of the master.
  • communicationStepSize::fmi2Real: Argument communicationStepSize contains a value of type fmi2Real which is a identifier for a variable value. communicationStepSize defines the communiction step size.
  • noSetFMUStatePriorToCurrentPoint::fmi2Boolean: Argument noSetFMUStatePriorToCurrentPoint contains a value of type fmi2Boolean which is a identifier for a variable value. noSetFMUStatePriorToCurrentPoint indicates whether fmi2SetFMUStatewill no longer be called for time instants prior to currentCommunicationPoint in this simulation run.

Keywords

  • currentCommunicationPoint::Union{Real, Nothing} = nothing: Argument currentCommunicationPoint contains a value of type Real or type Nothing. If no argument is passed the default value nothing is used. currentCommunicationPoint defines the current communication point of the master.
  • noSetFMUStatePriorToCurrentPoint::Bool = true: Argument noSetFMUStatePriorToCurrentPoint contains a value of type Boolean. If no argument is passed the default value true is used. noSetFMUStatePriorToCurrentPoint indicates whether fmi2SetFMUState is no longer called for times before the currentCommunicationPoint in this simulation run Simulation run.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.104]: 4.2.2 Computation
FMI.fmiEnterContinuousTimeModeMethod

DEPRECATED fmiEnterContinuousTimeMode(str::fmi2Struct)

The model enters Continuous-Time Mode and all discrete-time equations become inactive and all relations are “frozen”. This function has to be called when changing from Event Mode into Continuous-Time Mode.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.83]: 3.2.2 Evaluation of Model Equations
FMI.fmiEnterInitializationModeMethod

DEPRECATED fmiEnterInitializationMode(str::fmi2Struct)

Informs the FMU to enter initializaton mode, version independent.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.

Returns

  • Returns a warning if str.state is not called in fmi2ComponentStateInstantiated.
  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.23]: 2.1.6 Initialization, Termination, and Resetting an FMU
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiExitInitializationModeMethod

DEPRECATED fmiExitInitializationMode(str::fmi2Struct)

Informs the FMU to exit initialization mode, version independent.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.

Returns

  • Returns a warning if str.state is not called in fmi2ComponentStateInitializationMode.
  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.23]: 2.1.6 Initialization, Termination, and Resetting an FMU
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiFreeInstance!Method

DEPRECATED fmiFreeInstance!(str::fmi2Struct)

Frees the allocated memory of the last instance of the FMU.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.23]: 2.1.6 Initialization, Termination, and Resetting an FMU
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiGet!Method
fmiGet!(str::fmi2Struct, comp::FMU2Component, vrs::fmi2ValueReferenceFormat, dstArray::AbstractArray)

Stors the specific value of fmi2ScalarVariable containing the modelVariables with the identical fmi2ValueReference in an array.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • dstArray::AbstractArray: Stores the specific value of fmi2ScalarVariable containing the modelVariables with the identical fmi2ValueReference to the input variable vr (vr = vrs[i]). dstArray has the same length as vrs.

Returns

  • retcodes::Array{fmi2Status}: Returns an array of length length(vrs) with Type fmi2Status. Type fmi2Status is an enumeration and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.23]: 2.1.6 Initialization, Termination, and Resetting an FMU
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiGetMethod
fmiGet(str::fmi2Struct, comp::FMU2Component, vrs::fmi2ValueReferenceFormat)

Returns the specific value of fmi2ScalarVariable containing the modelVariables with the identical fmi2ValueReference in an array.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vrs::fmi2ValueReferenceFormat: wildcards for how a user can pass a fmi[X]ValueReference

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

Returns

  • dstArray::Array{Any,1}(undef, length(vrs)): Stores the specific value of fmi2ScalarVariable containing the modelVariables with the identical fmi2ValueReference to the input variable vr (vr = vrs[i]). dstArray is a 1-Dimensional Array that has the same length as vrs.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.23]: 2.1.6 Initialization, Termination, and Resetting an FMU
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiGetBoolean!Method

DEPRECATED fmiGetBoolean!(str::fmi2Struct, c::FMU2Component, vr::fmi2ValueReferenceFormat, values::Array{fmi2Boolean})

Writes the boolean values of an array of variables in the given field

fmi2GetBoolean! is only possible for arrays of values, please use an array instead of a scalar.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vr::fmi2ValueReferenceFormat: Argument vr defines the value references of the variables.

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

  • vr::Array{fmi2ValueReference}: Argument vr is an array of nvr value handels called "ValueReference" that define the variable that shall be inquired.
  • nvr::Csize_t: Argument nvr defines the size of vr.
  • values::Union{Array{<:Integer}, <:Integer}: Argument values is an array or a single value with type Integer or any subtyp
  • value::Array{fmi2Integer}: Argument values is an array with the actual values of these variables.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.24]: 2.1.7 Getting and Setting Variable Values
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiGetBooleanMethod

DEPRECATED fmiGetBoolean(str::fmi2Struct, c::FMU2Component, vr::fmi2ValueReferenceFormat)

Returns the boolean values of an array of variables

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vr::fmi2ValueReferenceFormat: Argument vr defines the value references of the variables.

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

Returns

  • values::Array{fmi2Boolean}: Return values is an array with the actual values of these variables.
FMI.fmiGetContinuousStatesMethod

DEPRECATED fmiGetContinuousStates(s::fmi2Struct)

Return the new (continuous) state vector x

Arguments

  • s::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • s::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • s::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.

Returns

  • x::Array{fmi2Real}: Returns an array of fmi2Real values representing the new continuous state vector x.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.83]: 3.2.2 Evaluation of Model Equations
FMI.fmiGetDirectionalDerivative!Method

DEPRECATEDTODO -> Arguments fmiGetDirectionalDerivative!(str::fmi2Struct, c::FMU2Component, vUnknownref::AbstractArray{fmi2ValueReference}, vKnownref::AbstractArray{fmi2ValueReference}, dvUnknown::AbstractArray, dvKnown::Union{Array{fmi2Real}, Nothing} = nothing)

fmiGetDirectionalDerivative!(str::fmi2Struct, c::FMU2Component,
                                   vUnknown_ref::AbstractArray{fmi2ValueReference},
                                   nUnknown::Csize_t,
                                   vKnown_ref::AbstractArray{fmi2ValueReference},
                                   nKnown::Csize_t,
                                   dvKnown::AbstractArray{fmi2Real},
                                   dvUnknown::AbstractArray)

Wrapper Function call to compute the partial derivative with respect to the variables vKnown_ref.

Computes the directional derivatives of an FMU. An FMU has different Modes and in every Mode an FMU might be described by different equations and different unknowns.The precise definitions are given in the mathematical descriptions of Model Exchange (section 3.1) and Co-Simulation (section 4.1). In every Mode, the general form of the FMU equations are: 𝐯unknown = 𝐡(𝐯known, 𝐯_rest)

  • v_unknown: vector of unknown Real variables computed in the actual Mode:
    • Initialization Mode: unkowns kisted under <ModelStructure><InitialUnknowns> that have type Real.
    • Continuous-Time Mode (ModelExchange): The continuous-time outputs and state derivatives. (= the variables listed under <ModelStructure><Outputs> with type Real and variability = continuous and the variables listed as state derivatives under <ModelStructure><Derivatives>).
    • Event Mode (ModelExchange): The same variables as in the Continuous-Time Mode and additionally variables under <ModelStructure><Outputs> with type Real and variability = discrete.
    • Step Mode (CoSimulation): The variables listed under <ModelStructure><Outputs> with type Real and variability = continuous or discrete. If <ModelStructure><Derivatives> is present, also the variables listed here as state derivatives.
  • v_known: Real input variables of function h that changes its value in the actual Mode.
  • v_rest:Set of input variables of function h that either changes its value in the actual Mode but are non-Real variables, or do not change their values in this Mode, but change their values in other Modes

Computes a linear combination of the partial derivatives of h with respect to the selected input variables 𝐯_known:

Δvunknown = (δh / δvknown) Δv_known

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vUnknown_ref::AbstracArray{fmi2ValueReference}: Argument vUnknown_ref contains values of typefmi2ValueReference which are identifiers of a variable value of the model. vUnknown_ref can be equated with v_unknown(variable described above).
  • vKnown_ref::AbstractArray{fmi2ValueReference}: Argument vKnown_ref contains values of type fmi2ValueReference which are identifiers of a variable value of the model.vKnown_ref can be equated with v_known(variable described above).
  • dvUnknown::AbstractArray: Stores the directional derivative vector values.
  • dvKnown::Union{Array{fmi2Real}, Nothing} = nothing: If no seed vector is passed the value nothing is used. The vector values Compute the partial derivative with respect to the given entries in vector vKnown_ref with the matching evaluate of dvKnown.
  • dvKnown::AbstractArray{fmi2Real}:The vector values Compute the partial derivative with respect to the given entries in vector vKnown_ref with the matching evaluate of dvKnown.
  • nUnknown::Csize_t:
  • nKnown::Csize_t:

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.25]: 2.1.9 Getting Partial Derivatives
FMI.fmiGetDirectionalDerivativeMethod

DEPRECATED fmiGetDirectionalDerivative(str::fmi2Struct, c::FMU2Component, vUnknownref::AbstractArray{fmi2ValueReference}, vKnownref::AbstractArray{fmi2ValueReference}, dvKnown::Union{AbstractArray{fmi2Real}, Nothing} = nothing)

fmi2GetDirectionalDerivative(str::fmi2Struct, c::FMU2Component,
                                    vUnknown_ref::fmi2ValueReference,
                                    vKnown_ref::fmi2ValueReference,
                                    dvKnown::fmi2Real = 1.0)

The Wrapper Function and the Direct function call to compute the partial derivative with respect to vKnown_ref.

Computes the directional derivatives of an FMU. An FMU has different Modes and in every Mode an FMU might be described by different equations and different unknowns.The precise definitions are given in the mathematical descriptions of Model Exchange (section 3.1) and Co-Simulation (section 4.1). In every Mode, the general form of the FMU equations are: 𝐯unknown = 𝐡(𝐯known, 𝐯_rest)

  • v_unknown: vector of unknown Real variables computed in the actual Mode:
    • Initialization Mode: unkowns kisted under <ModelStructure><InitialUnknowns> that have type Real.
    • Continuous-Time Mode (ModelExchange): The continuous-time outputs and state derivatives. (= the variables listed under <ModelStructure><Outputs> with type Real and variability = continuous and the variables listed as state derivatives under <ModelStructure><Derivatives>).
    • Event Mode (ModelExchange): The same variables as in the Continuous-Time Mode and additionally variables under <ModelStructure><Outputs> with type Real and variability = discrete.
    • Step Mode (CoSimulation): The variables listed under <ModelStructure><Outputs> with type Real and variability = continuous or discrete. If <ModelStructure><Derivatives> is present, also the variables listed here as state derivatives.
  • v_known: Real input variables of function h that changes its value in the actual Mode.
  • v_rest:Set of input variables of function h that either changes its value in the actual Mode but are non-Real variables, or do not change their values in this Mode, but change their values in other Modes

Computes a linear combination of the partial derivatives of h with respect to the selected input variables 𝐯_known:

Δv_unknown = (δh / δv_known) Δv_known

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vUnknown_ref::AbstractArray{fmi2ValueReference}: Argument vUnknown_ref contains values of typefmi2ValueReference which are identifiers of a variable value of the model. vUnknown_ref can be equated with v_unknown(variable described above).
  • vUnknown_ref::fmi2ValueReference: Argument vUnknown_ref contains a value of typefmi2ValueReference which is an identifier of a variable value of the model. vUnknown_ref can be equated with v_unknown(variable described above).
  • vKnown_ref::AbstractArray{fmi2ValueReference}: Argument vKnown_ref contains values of type fmi2ValueReference which are identifiers of a variable value of the model.vKnown_ref can be equated with v_known(variable described above).
  • vKnown_ref::fmi2ValueReference: Argument vKnown_ref contains a value of typefmi2ValueReference which is an identifier of a variable value of the model. vKnown_ref can be equated with v_known(variable described above).
  • dvKnown::Union{AbstractArray{fmi2Real}, Nothing} = nothing: If no seed vector is passed the value nothing is used. The vector values Compute the partial derivative with respect to the given entries in vector vKnown_ref with the matching evaluate of dvKnown.
  • dvKnown::Fmi2Real = 1.0: If no seed value is passed the value dvKnown = 1.0 is used. Compute the partial derivative with respect to vKnown_ref with the value dvKnown = 1.0. # gehört das zu den v_rest values

Returns

  • dvUnknown::Array{fmi2Real}: Return dvUnknown contains the directional derivative vector values.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.25]: 2.1.9 Getting Partial Derivatives
FMI.fmiGetEventIndicatorsMethod

DEPRECATED fmiGetEventIndicators(str::fmi2Struct)

Returns the event indicators of the FMU

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.

Returns

  • eventIndicators::Array{fmi2Real}:The event indicators are returned as a vector represented by an array of "fmi2Real" values.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.83]: 3.2.2 Evaluation of Model Equations
FMI.fmiGetInteger!Method

DEPRECATED function fmiGetInteger!(str::fmi2Struct, c::FMU2Component, vr::fmi2ValueReferenceFormat, values::Array{fmi2Integer})

function fmiGetInteger!(str::fmi2Struct, c::FMU2Component, vr::fmi2ValueReferenceFormat, values::Array{fmi2Integer})

Writes the integer values of an array of variables in the given field

fmi2GetInteger! is only possible for arrays of values, please use an array instead of a scalar.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vr::fmi2ValueReferenceFormat: Argument vr defines the value references of the variables.

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

  • vr::Array{fmi2ValueReference}: Argument vr is an array of nvr value handels called "ValueReference" that define the variable that shall be inquired.
  • nvr::Csize_t: Argument nvr defines the size of vr.
  • values::Array{fmi2Integer}: Argument values is an array with the actual values of these variables.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.24]: 2.1.7 Getting and Setting Variable Values
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiGetIntegerMethod

DEPRECATED fmiGetInteger(str::fmi2Struct,c::FMU2Component, vr::fmi2ValueReferenceFormat)

Returns the integer values of an array of variables

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vr::fmi2ValueReferenceFormat: Argument vr defines the value references of the variables

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

Returns

  • values::Array{fmi2Integer}: Return values is an array with the actual values of these variables.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.24]: 2.1.7 Getting and Setting Variable Values
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiGetModelIdentifierMethod
fmiGetModelIdentifier(fmu::Union{FMU2, FMU3})

Returns the tag 'modelIdentifier' from CS or ME section.

Arguments

  • fmu::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • fmu::FMU3: Mutable struct representing a FMU and all it instantiated instances in the FMI 3.0 Standard.

Returns

  • fmu.modelDescription.coSimulation.modelIdentifier: The function fmiGetModelIdentifier returns the tag 'coSimulation.modelIdentifier' from the model description of the FMU2 or FMU3-struct (fmu.modelDescription), if the FMU supports co simulation.
  • fmu.modelDescription.modelExchange.modelIdentifier: The function fmiGetModelIdentifier returns the tag 'modelExchange.modelIdentifier' from the model description of the FMU2 or FMU3-struct (fmu.modelDescription), if the FMU supports model exchange
  • fmu.modelDescription.modelExchange.modelIdentifier: The function fmiGetModelIdentifier returns the tag 'scheduledExecution.modelIdentifier' from the model description of the FMU3-struct (fmu.modelDescription), if the FMU supports scheduled execution

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.22]: 2.1.4 Inquire Platform and Version Number of Header Files
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions

Also see fmi2GetModelIdentifier, FMU2, fmi3GetModelIdentifier, FMU3.

FMI.fmiGetNominalsOfContinuousStatesMethod

DEPRECATED fmiGetNominalsOfContinuousStates(s::fmi2Struct)

Return the new (continuous) state vector x

Arguments

  • s::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • s::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • s::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.

Returns

  • x::Array{fmi2Real}: Returns an array of fmi2Real values representing the new continuous state vector x.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.83]: 3.2.2 Evaluation of Model Equations
FMI.fmiGetNumberOfStatesMethod
fmiGetNumberOfStates(str::Union{fmi2Struct, fmi3Struct})

Returns the number of states of the FMU.

Arguments

More detailed: fmi2Struct = Union{FMU2, FMU2Component} More detailed: fmi3StructMD = Union{FMU3, FMU3Instance, fmi3ModelDescription}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • str::FMU3: Mutable struct representing an FMU in the FMI 3.0 Standard.
  • str::FMU3Instance: Mutable struct represents a pointer to an FMU specific data structure that contains the information needed. Also in FMI 3.0 Standard.

Returns

  • Returns the length of the md.valueReferences::Array{fmi2ValueReference} corresponding to the number of states of the FMU.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.22]: 2.1.4 Inquire Platform and Version Number of Header Files
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions

See also fmi2GetNumberOfStates, fmi2Struct, FMU2, FMU2Component, , fmi3Struct, FMU3, FMU3Instance.

FMI.fmiGetReal!Method

DEPRECATED fmiGetReal!(str::fmi2Struct, c::FMU2Component, vr::fmi2ValueReferenceFormat, values::Array{fmi2Real})

fmiGetReal!(str::fmi2Struct, c::FMU2Component, vr::Array{fmi2ValueReference}, nvr::Csize_t, value::Array{fmi2Real})

Writes the real values of an array of variables in the given field

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vr::fmi2ValueReferenceFormat: Wildcards for how a user can pass a fmi[X]ValueReference

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

  • vr::Array{fmi2ValueReference}: Argument vr is an array of nvr value handels called "ValueReference" that define the variable that shall be inquired.
  • nvr::Csize_t: Argument nvr defines the size of vr.
  • values::Array{fm2Real}: Argument values is an array with the actual values of these variables.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.24]: 2.1.7 Getting and Setting Variable Values
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiGetRealMethod
fmiGetReal(str::fmi2Struct, vr::fmi2ValueReferenceFormat)

Returns the real values of an array of variables

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vr::fmi2ValueReferenceFormat: wildcards for how a user can pass a fmi[X]ValueReference

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

Returns

  • values::Array{fm2Real}: returns values of an array of fmi2Real variables with the dimension of fmi2ValueReferenceFormat length.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.24]: 2.1.7 Getting and Setting Variable Values
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions

See also fmi2GetReal,fmi2ValueReferenceFormat, fmi2Struct, FMU2, FMU2Component.

FMI.fmiGetStartValueMethod
fmiGetStartValue(s::fmi2Struct, vr::fmi2ValueReferenceFormat)

Returns the start/default value for a given value reference.

Arguments

  • md::fmi2ModelDescription: Struct which provides the static information of ModelVariables.
  • vrs::fmi2ValueReferenceFormat = md.valueReferences: wildcards for how a user can pass a fmi[X]ValueReference (default = md.valueReferences)

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

Returns

  • starts::Array{fmi2ValueReferenceFormat}: start/default value for a given value reference
FMI.fmiGetString!Method

DEPRECATED fmiGetString!(str::fmi2Struct, c::FMU2Component, vr::fmi2ValueReferenceFormat, values::Array{fmi2String})

fmiGetString!(str::fmi2Struct, c::FMU2Component, vr::Array{fmi2ValueReference}, nvr::Csize_t, value::Vector{Ptr{Cchar}})

Writes the string values of an array of variables in the given field

These functions are especially used to get the actual values of output variables if a model is connected with other models.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vr::fmi2ValueReferenceFormat: Argument vr defines the value references of the variables.

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

  • vr::Array{fmi2ValueReference}: Array of the FMI2 Data Typ fmi2ValueReference
  • nvr::Csize_t: Argument nvr defines the size of vr.
  • values::Union{Array{Bool}, Bool}: Argument values is an array or a single value with type Boolean or any subtyp.
  • value::Vector{Ptr{Cchar}}: Argument values is an vector with the actual values of these variables.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.24]: 2.1.7 Getting and Setting Variable Values
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiGetStringMethod

DEPRECATED fmiGetString(str::fmi2Struct, c::FMU2Component, vr::fmi2ValueReferenceFormat)

Returns the string values of an array of variables

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vr::fmi2ValueReferenceFormat: Argument vr defines the value references of the variables.

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

Returns

  • values::Array{fmi2String}: Return values is an array with the actual values of these variables.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.24]: 2.1.7 Getting and Setting Variable Values
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiGetTypesPlatformMethod
fmiGetTypesPlatform(str::fmi2Struct)

Returns the header file used to compile the FMU. By default returns default, version independent.

Arguments

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.

Returns

  • Returns the string to uniquely identify the “fmi2TypesPlatform.h” header file used for compilation of the functions of the FMU.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.22]: 2.1.4 Inquire Platform and Version Number of Header Files
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions

See also fmi2GetVersion, fmi2Struct, FMU2, FMU2Component.

FMI.fmiGetVersionMethod
fmiGetVersion(str::Union{fmi2Struct, fmi3Struct})

Returns the version of the FMU, version independent.

Arguments

More detailed: fmi2Struct = Union{FMU2, FMU2Component} More detailed: fmi3StructMD = Union{FMU3, FMU3Instance, fmi3ModelDescription}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • str::FMU3: Mutable struct representing an FMU in the FMI 3.0 Standard.
  • str::FMU3Instance: Mutable struct represents a pointer to an FMU specific data structure that contains the information needed. Also in FMI 3.0 Standard.

Returns

  • Returns a string from the address of a C-style (NUL-terminated) string. The string represents the version of the “fmiXFunctions.h” header file which was used to compile the functions of the FMU. The function returns “fmiVersion” which is defined in this header file. The standard header file as documented in this specification has version “2.0” or "3.0"

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.22]: 2.1.4 Inquire Platform and Version Number of Header Files
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions
  • FMISpec3.0[p. ]: 2.2.5. Inquire Version Number of Header Files

See also fmi2GetVersion, unsafe_string, fmi2Struct, FMU2, FMU2Component, fmi3GetVersion, fmi3Struct, FMU3, FMU3Instance.

FMI.fmiInfoMethod
fmiInfo(str::fmi2Struct)

Prints FMU-specific information into the REPL.

Arguments

More detailed: fmi2Struct = Union{FMU2, FMU2Component} More detailed: fmi3StructMD = Union{FMU3, FMU3Instance, fmi3ModelDescription}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • str::FMU3: Mutable struct representing an FMU in the FMI 3.0 Standard.
  • str::FMU3Instance: Mutable struct represents a pointer to an FMU specific data structure that contains the information needed. Also in FMI 3.0 Standard.

Returns

  • Prints FMU related information.

Source

See also fmi2Info, fmi2Struct, FMU2, FMU2Component, fmi3Info, fmi3Struct, FMU3, FMU3Instance.

FMI.fmiInstantiate!Method

DEPRECATED fmiInstantiate!(fmu::FMU2; pushComponents::Bool = true, visible::Bool = false, loggingOn::Bool = false, externalCallbacks::Bool = false, logStatusOK::Bool=true, logStatusWarning::Bool=true, logStatusDiscard::Bool=true, logStatusError::Bool=true, logStatusFatal::Bool=true, logStatusPending::Bool=true)

Creates a new instance of the FMU, version independent.

Create a new instance of the given fmu, adds a logger if logginOn == true.

Arguments

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.

Keywords

  • pushComponents::Bool = true: pushComponents if the item component should be inserted in fmu.components(default = true).
  • visible::Bool = false: visible if the FMU should be started with graphic interface, if supported (default=false)
  • loggingOn::Bool = false: loggingOn if the FMU should log and display function calls (default=false)
  • externalCallbacks::Bool = false: externalCallbacks if an external DLL should be used for the fmi2CallbackFunctions, this may improve readability of logging messages (default=false)
  • logStatusOK::Bool=true: logStatusOK whether to log status of kind fmi2OK (default=true)
  • logStatusWarning::Bool=true: logStatusWarning whether to log status of kind fmi2Warning (default=true)
  • logStatusDiscard::Bool=true: logStatusDiscard whether to log status of kind fmi2Discard (default=true)
  • logStatusError::Bool=true: logStatusError whether to log status of kind fmi2Error (default=true)
  • logStatusFatal::Bool=true: logStatusFatal whether to log status of kind fmi2Fatal (default=true)
  • logStatusPending::Bool=true: logStatusPending whether to log status of kind fmi2Pending (default=true)

Returns

  • nothing: if the instantiation failed. In addition, an error message appears.
  • component: Returns the instance of a new FMU component.

Source

FMI.fmiIsCoSimulationMethod
fmiIsCoSimulation(str::Union{fmi2StructMD, fmi3StructMD})

Returns true, if the FMU supports co simulation

Arguments

More detailed: fmi2StructMD = Union{FMU2, FMU2Component, fmi2ModelDescription} More detailed: fmi3StructMD = Union{FMU3, FMU3Instance, fmi3ModelDescription}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • str::fmi2ModelDescription: Struct witch provides the static information of ModelVariables.
  • str::FMU3: Mutable struct representing an FMU in the FMI 3.0 Standard.
  • str::FMU3Instance: Mutable struct represents a pointer to an FMU specific data structure that contains the information needed. Also in FMI 3.0 Standard.
  • str::fmi3ModelDescription: Struct witch provides the static information of ModelVariables.

Returns

  • ::Bool: The function fmi2IsCoSimulation returns True, if the FMU supports co simulation

See also fmi2IsCoSimulation, fmi2StructMD, FMU2, FMU2Component, fmi2ModelDescription, fmi3IsCoSimulation, fmi3StructMD, FMU3, FMU3Instance, fmi3ModelDescription.

FMI.fmiIsModelExchangeMethod
fmiIsModelExchange(str::Union{fmi2StructMD, fmi3StructMD})

Returns true, if the FMU supports model exchange

Arguments

More detailed: fmi2StructMD = Union{FMU2, FMU2Component, fmi2ModelDescription} More detailed: fmi3StructMD = Union{FMU3, FMU3Instance, fmi3ModelDescription}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • str::fmi2ModelDescription: Struct witch provides the static information of ModelVariables.
  • str::FMU3: Mutable struct representing an FMU in the FMI 3.0 Standard.
  • str::FMU3Instance: Mutable struct represents a pointer to an FMU specific data structure that contains the information needed. Also in FMI 3.0 Standard.
  • str::fmi3ModelDescription: Struct witch provides the static information of ModelVariables.

Returns

  • ::Bool: The function fmi2IsModelExchange returns True, if the FMU supports model exchange.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.22]: 2.1.4 Inquire Platform and Version Number of Header Files
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions

See also fmi2IsModelExchange, fmi2StructMD, FMU2, FMU2Component, fmi2ModelDescription, fmi3IsModelExchange, fmi3StructMD, FMU3, FMU3Instance, fmi3ModelDescription.

FMI.fmiIsScheduledExecutionMethod
fmiIsScheduledExecution(str::fmi3StructMD)

Returns true, if the FMU supports scheduled execution

Arguments

  • str::fmi3StructMD: Representative for an FMU in the FMI 3.0 Standard. Other notation:

More detailed: fmi3StructMD = Union{FMU3, FMU3Instance, fmi3ModelDescription}

  • str::FMU3: Mutable struct representing an FMU in the FMI 3.0 Standard.
  • str::FMU3Instance: Mutable struct represents a pointer to an FMU specific data structure that contains the information needed. Also in FMI 3.0 Standard.
  • str::fmi3ModelDescription: Struct witch provides the static information of ModelVariables.

Returns

  • ::Bool: The function fmi3IsScheduledExecution returns True, if the FMU supports scheduled execution.

See also fmi3IsScheduledExecution, fmi3StructMD, FMU3, FMU3Instance, fmi3ModelDescription.

FMI.fmiLoadMethod
fmiLoad(pathToFMU::String; unpackPath=nothing, type=nothing)

Load FMUs independent of the FMI version, currently supporting version 2.0.X and 3.0.

Arguments

  • pathToFMU::String: String that contains the paths of ziped and unziped FMU folders.

Keywords

  • unpackPath=nothing: Via optional argument unpackPath, a path to unpack the FMU can be specified (default: system temporary directory).
  • type::Union{CS, ME, SE} = nothing: Via type, a FMU type can be selected. If none of the unified type set is used, the default value type = nothing will be used.

Returns

  • Returns the instance of the FMU struct.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.22]: 2.1.4 Inquire Platform and Version Number of Header Files
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions

See also fmi2Load, fmi3Load.

FMI.fmiNewDiscreteStatesMethod

DEPRECATED fmiNewDiscreteStates(str::fmi2Struct)

Returns the next discrete states

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.

Returns

  • eventInfo::fmi2EventInfo*: Strut with fmi2Boolean Variables

More detailed:

  • newDiscreteStatesNeeded::fmi2Boolean: If newDiscreteStatesNeeded = fmi2True the FMU should stay in Event Mode, and the FMU requires to set new inputs to the FMU to compute and get the outputs and to call

fmi2NewDiscreteStates again. If all FMUs return newDiscreteStatesNeeded = fmi2False call fmi2EnterContinuousTimeMode.

  • terminateSimulation::fmi2Boolean: If terminateSimulation = fmi2True call fmi2Terminate
  • nominalsOfContinuousStatesChanged::fmi2Boolean: If nominalsOfContinuousStatesChanged = fmi2True then the nominal values of the states have changed due to the function call and can be inquired with fmi2GetNominalsOfContinuousStates.
  • valuesOfContinuousStatesChanged::fmi2Boolean: If valuesOfContinuousStatesChanged = fmi2True, then at least one element of the continuous state vector has changed its value due to the function call. The new values of the states can be retrieved with fmi2GetContinuousStates. If no element of the continuous state vector has changed its value, valuesOfContinuousStatesChanged must return fmi2False.
  • nextEventTimeDefined::fmi2Boolean: If nextEventTimeDefined = fmi2True, then the simulation shall integrate at most until time = nextEventTime, and shall call fmi2EnterEventMode at this time instant. If integration is stopped before nextEventTime, the definition of nextEventTime becomes obsolete.
  • nextEventTime::fmi2Real: next event if nextEventTimeDefined=fmi2True

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.83]: 3.2.2 Evaluation of Model Equations
FMI.fmiProvidesAdjointDerivativeMethod
fmiProvidesAdjointDerivative(str::fmi3StructMD)

Returns true, if the FMU provides adjoint derivatives

Arguments

  • str::fmi3StructMD: Representative for an FMU in the FMI 3.0 Standard. Other notation:

More detailed: fmi3StructMD = Union{FMU3, FMU3Component, fmi3ModelDescription}

  • str::FMU3: Mutable struct representing an FMU in the FMI 3.0 Standard.
  • str::FMU3Instance: Mutable struct represents a pointer to an FMU specific data structure that contains the information needed. Also in FMI 3.0 Standard.
  • str::fmi3ModelDescription: Struct witch provides the static information of ModelVariables.

Returns

  • ::Bool: The function fmi3ProvidesAdjointDerivatives returns True, if the FMU provides adjoint derivatives.

See also fmi3ProvidesAdjointDerivatves, fmi3StructMD, FMU3, FMU3Instance, fmi3ModelDescription.

FMI.fmiProvidesDirectionalDerivativeMethod
fmiProvidesDirectionalDerivative(str::Union{fmi2StructMD, fmi3StructMD})

Returns true, if the FMU provides directional derivatives

Arguments

More detailed: fmi2StructMD = Union{FMU2, FMU2Component, fmi2ModelDescription} More detailed: fmi3StructMD = Union{FMU3, FMU3Instance, fmi3ModelDescription}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • str::fmi2ModelDescription: Struct witch provides the static information of ModelVariables.
  • str::FMU3: Mutable struct representing an FMU in the FMI 3.0 Standard.
  • str::FMU3Instance: Mutable struct represents a pointer to an FMU specific data structure that contains the information needed. Also in FMI 3.0 Standard.
  • str::fmi3ModelDescription: Struct witch provides the static information of ModelVariables.

Returns

  • ::Bool: The function fmi2ProvidesDirectionalDerivative returns True, if the FMU provides directional derivatives.

See also fmi2ProvidesDirectionalDerivative, fmi2StructMD, FMU2, FMU2Component, fmi2ModelDescription, fmi3ProvidesDirectionalDerivatives, fmi3StructMD, FMU3, FMU3Instance, fmi3ModelDescription.

FMI.fmiReloadMethod
fmiReload(fmu::Union{FMU2, FMU3})

Reloads the FMU-binary. This is useful, if the FMU does not support a clean reset implementation.

Arguments

  • fmu::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • fmu::FMU3: Mutable struct representing an FMU in the FMI 3.0 Standard.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.22]: 2.1.4 Inquire Platform and Version Number of Header Files
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions

See also fmi2Reload, fmi3Reload.

FMI.fmiResetMethod

DEPRECATED fmiReset(str::fmi2Struct)

Resets the FMU after a simulation run, version independent.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.

Returns

  • Returns a warning if str.state is not called in fmi2ComponentStateTerminated or fmi2ComponentStateError.
  • Returns an error if the reinstantiation failed.
  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.23]: 2.1.6 Initialization, Termination, and Resetting an FMU
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiSampleJacobianMethod
fmiSampleJacobian(str::fmi2Struct, c::FMU2Component,
                                   vUnknown_ref::Array{fmi2ValueReference},
                                   vKnown_ref::Array{fmi2ValueReference},
                                   steps::Array{fmi2Real} = ones(fmi2Real, length(vKnown_ref)).*1e-5)
fmiSampleJacobian(str::fmi2Struct, c::FMU2Component,
                                   vUnknown_ref::AbstractArray{fmi2ValueReference},
                                   vKnown_ref::AbstractArray{fmi2ValueReference},
                                   steps::Union{AbstractArray{fmi2Real}, Nothing} = nothing)

This function samples the jacobian by manipulating corresponding values (central differences).

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vUnknown_ref::Array{fmi2ValueReference}: Argument vUnKnown_ref contains values of type fmi2ValueReference which are identifiers of a variable value of the model.vKnown_ref is the Array of the vector values of Real input variables of function h that changes its value in the actual Mode.
  • vKnown_ref::Array{fmi2ValueReference}: Argument vKnown_ref contains values of type fmi2ValueReference which are identifiers of a variable value of the model.vKnown_ref is the Array of the vector values of Real input variables of function h that changes its value in the actual Mode.
  • steps::Array{fmi2Real} = ones(fmi2Real, length(vKnown_ref)).*1e-5: Predefined step size vector steps, where all entries have the value 1e-5.
  • steps::Union{AbstractArray{fmi2Real}, Nothing} = nothing: Step size to be used for numerical differentiation. If nothing, a default value will be chosen automatically.

Returns

  • dvUnknown::Arrya{fmi2Real}:

Source

See also fmi2SampleJacobian, fmi2Struct, FMU2, FMU2Component, fmi2ValueReference.

FMI.fmiSaveSolutionMethod
fmiSaveSolution(solution::FMUSolution, filepath::AbstractString [; keyword="solution"])

Save a solution of an FMU simulation at filepath.

Currently .mat, .jld2 and .csv are supported for saving and selected by the ending of filepath. For JLD2 the keyword is used as key. Loading a FMUSolution into FMI.jl is currently only possible for .jld2 files.

See also fmiSaveSolutionCSV, fmiSaveSolutionMAT, fmiSaveSolutionJLD2, fmiLoadSolutionJLD2.

FMI.fmiSerializeFMUstateMethod

DEPRECATED fmiSerializeFMUstate(str::fmi2Struct, c::FMU2Component, state::fmi2FMUstate)

Serializes the data referenced by the pointer FMUstate and copies this data into the byte vector serializedState of length size to be provided by the environment.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • state::fmi2FMUstate: Argument state is a pointer to a data structure in the FMU that saves the internal FMU state of the actual or a previous time instant.

Returns

  • serialized:: Array{fmi2Byte}: Return serializedState contains the copy of the serialized data referenced by the pointer FMUstate

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.25]: 2.1.8 Getting and Setting the Complete FMU State
FMI.fmiSerializedFMUstateSizeMethod

DEPRECATED fmiSerializedFMUstateSize(str::fmi2Struct, c::FMU2Component, state::fmi2FMUstate)

Returns the size of the byte vector in which the FMUstate can be stored.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • state::fmi2FMUstate: Argument state is a pointer to a data structure in the FMU that saves the internal FMU state of the actual or a previous time instant.

Returns

  • Return size is an object that safely references a value of type Csize_t.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.25]: 2.1.8 Getting and Setting the Complete FMU State
FMI.fmiSetMethod
fmiSet(str::fmi2Struct, comp::FMU2Component, vrs::fmi2ValueReferenceFormat, srcArray::AbstractArray; filter=nothing)

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • srcArray::AbstractArray: Stores the specific value of fmi2ScalarVariable containing the modelVariables with the identical fmi2ValueReference to the input variable vr (vr = vrs[i]). srcArray has the same length as vrs.

Keywords

  • filter=nothing: whether the individual values of "fmi2ScalarVariable" are to be stored

Returns

  • retcodes::Array{fmi2Status}: Returns an array of length length(vrs) with Type fmi2Status. Type fmi2Status is an enumeration and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.23]: 2.1.6 Initialization, Termination, and Resetting an FMU
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiSetBooleanMethod

DEPRECATED fmiSetBoolean(str::fmi2Struct, c::FMU2Component, vr::Array{fmi2ValueReference}, nvr::Csize_t, value::Array{fmi2Boolean})

fmiSetBoolean(str::fmi2Struct, c::FMU2Component, vr::fmi2ValueReferenceFormat, values::Union{Array{Bool}, Bool})

Set the values of an array of boolean variables

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vr::fmi2ValueReferenceFormat: Argument vr defines the value references of the variables.

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

  • vr::Array{fmi2ValueReference}: Array of the FMI2 Data Typ fmi2ValueReference
  • nvr::Csize_t: Argument nvr defines the size of vr.
  • values::Union{Array{Bool}, Bool}: Argument values is an array or a single value with type Boolean or any subtyp
  • value::Array{fmi2Boolean}: Argument values is an array with the actual values of these variables.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.24]: 2.1.7 Getting and Setting Variable Values
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiSetContinuousStatesMethod

DEPRECATED fmiSetContinuousStates(str::fmi2Struct, c::FMU2Component, x::AbstractArray{fmi2Real}, nx::Csize_t)

fmiSetContinuousStates(str::fmi2Struct, c::FMU2Component,
                             x::Union{AbstractArray{Float32},AbstractArray{Float64}})

Set a new (continuous) state vector

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • x::AbstractArray{fmi2Real}: Argument x contains values of type fmi2Real which is a alias type for Real data type.x is the AbstractArray of the vector values of Real input variables of function h that changes its value in the actual Mode.
  • x::Union{AbstractArray{Float32},AbstractArray{Float64}}:
  • nx::Csize_t: Argument nx defines the length of vector x and is provided for checking purposes

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.83]: 3.2.1 Providing Independent Variables and Re-initialization of Caching
FMI.fmiSetDebugLoggingMethod

DEPRECATED fmiSetDebugLogging(str::fmi2Struct)

Control the use of the logging callback function, version independent.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.22]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.22]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.22]: 2.1.5 Creation, Destruction and Logging of FMU Instances
FMI.fmiSetIntegerMethod

DEPRECATED fmiSetInteger(str::fmi2Struct, c::FMU2Component, vr::fmi2ValueReferenceFormat, values::Union{Array{<:Integer}, <:Integer})

fmiSetInteger(str::fmi2Struct, c::FMU2Component, vr::Array{fmi2ValueReference}, nvr::Csize_t, value::Array{fmi2Integer})

Set the values of an array of integer variables

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vr::fmi2ValueReferenceFormat: Argument vr defines the value references of the variables.

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

  • vr::Array{fmi2ValueReference}: Argument vr is an array of nvr value handels called "ValueReference" that define the variable that shall be inquired.
  • nvr::Csize_t: Argument nvr defines the size of vr.
  • values::Union{Array{<:Integer}, <:Integer}: Argument values is an array or a single value with type Integer or any subtyp
  • value::Array{fmi2Integer}: Argument values is an array with the actual values of these variables.

Returns

  • status::fmi2Status: Return status indicates the success of the function call.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.24]: 2.1.7 Getting and Setting Variable Values
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiSetRealMethod

DEPRECATED fmiSetReal(str::fmi2Struct, c::FMU2Component, vr::fmi2ValueReferenceFormat, values::Union{Array{<:Real}, <:Real})

fmiSetReal(str::fmi2Struct, c::FMU2Component, vr::Array{fmi2ValueReference}, nvr::Csize_t, value::Array{fmi2Real})

Set the values of an array of real variables

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vr::fmi2ValueReferenceFormat: Wildcards for how a user can pass a fmi[X]ValueReference

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

  • vr::Array{fmi2ValueReference}: Argument vr is an array of nvr value handels called "ValueReference" that define the variable that shall be inquired.
  • nvr::Csize_t: Argument nvr defines the size of vr.
  • values::Union{Array{<:Real}, <:Real}: Argument values is an array with the actual values of these variables.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.24]: 2.1.7 Getting and Setting Variable Values
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiSetRealInputDerivativesMethod

DEPRECATED#Todo: Add types according spec

fmiSetRealInputDerivatives(str::fmi2Struct, c::FMU2Component, vr::fmi2ValueReferenceFormat, order, values)

fmiSetRealInputDerivatives(str::fmi2Struct, c::FMU2Component, vr::Array{fmi2ValueReference}, nvr::Csize_t, order::Array{fmi2Integer}, value::Array{fmi2Real})

Sets the n-th time derivative of real input variables.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vr::fmi2ValueReferenceFormat: Argument vr defines the value references of the variables

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

  • vr::Array{fmi2ValueReference}: Argument vr is an array of nvr value handels called "ValueReference" that define the variable that shall be inquired.
  • nvr::Csize_t: Argument nvr defines the size of vr.
  • order::Array{fmi2Integer}: Argument order is an array of fmi2Integer values witch specifys the corresponding order of derivative of the real input variable.
  • values::Array{fmi2Real}: Argument values is an array with the actual values of these variables.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.104]: 4.2.1 Transfer of Input / Output Values and Parameters
FMI.fmiSetStringMethod

DEPRECATED fmiSetString(str::fmi2Struct, c::FMU2Component, vr::fmi2ValueReferenceFormat, values::Union{Array{String}, String})

fmiSetString(str::fmi2Struct, c::FMU2Component, vr::Array{fmi2ValueReference}, nvr::Csize_t, value::Union{Array{Ptr{Cchar}}, Array{Ptr{UInt8}}})

Set the values of an array of string variables

For the exact rules on which type of variables fmi2SetXXX can be called see FMISpec2.0.2 section 2.2.7 , as well as FMISpec2.0.2 section 3.2.3 in case of ModelExchange and FMISpec2.0.2 section 4.2.4 in case of CoSimulation.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • vr::fmi2ValueReferenceFormat: Argument vr defines the value references of the variables.

More detailed: fmi2ValueReferenceFormat = Union{Nothing, String, Array{String,1}, fmi2ValueReference, Array{fmi2ValueReference,1}, Int64, Array{Int64,1}, Symbol}

  • vr::Array{fmi2ValueReference}: Array of the FMI2 Data Typ fmi2ValueReference
  • nvr::Csize_t: Argument nvr defines the size of vr.
  • values::Union{Array{String}, String}: Argument values is an array or a single value with type String.
  • value::Vector{Ptr{Cchar}}: Argument values is an vector with the actual values of these variables.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.24]: 2.1.7 Getting and Setting Variable Values
  • FMISpec2.0.2[p.46]: 2.2.7 Definition of Model Variables
  • FMISpec2.0.2[p.46]: 3.2.3 State Machine of Calling Sequence
  • FMISpec2.0.2[p.108]: 4.2.4 State Machine of Calling Sequence from Master to Slave
FMI.fmiSetTimeMethod

DEPRECATED fmiSetTime(c::fmi2Struct, c::FMU2Component, time::fmi2Real)

fmiSetTime(c::fmi2Struct, c::FMU2Component, t::Real)

Set a new time instant and re-initialize caching of variables that depend on time.

Arguments

  • c::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • c::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • c::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • time::fmi2Real: Argument time contains a value of type fmi2Real which is a alias type for Real data type. time sets the independent variable time t.
  • t::Real: Argument t contains a value of type Real. t sets the independent variable time t.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.83]: 3.2.1 Providing Independent Variables and Re-initialization of Caching
FMI.fmiSetupExperimentMethod

DEPRECATED fmiSetupExperiment(str::fmi2Struct, c::FMU2Component, startTime::Union{Real, Nothing} = nothing, stopTime::Union{Real, Nothing} = nothing; tolerance::Union{Real, Nothing} = nothing)

Initialize the Simulation boundries

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • startTime::Union{Real, Nothing} = nothing: startTime is a real number which sets the value of starting time of the experiment. The default value is set automatically if doing nothing (default = nothing).
  • stopTime::Union{Real, Nothing} = nothing: stopTime is a real number which sets the value of ending time of the experiment. The default value is set automatically if doing nothing (default = nothing).

Keywords

  • tolerance::Union{Real, Nothing} = nothing: tolerance is a real number which sets the value of tolerance range. The default value is set automatically if doing nothing (default = nothing).

Returns

  • Returns a warning if str.state is not called in fmi2ComponentStateInstantiated.
  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.23]: 2.1.6 Initialization, Termination, and Resetting an FMU
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiSimulateMethod
fmiSimulate(str::fmi2Struct, args...; kwargs...)

Start a simulation of the FMU instance str for the matching FMU version and type.

Wrapper for fmi2Simulate.

FMI.fmiSimulateMethod
fmiSimulate(str::fmi3Struct, args...; kwargs...)

Start a simulation of the FMU instance str for the matching FMU version and type.

Wrapper for fmi3Simulate.

FMI.fmiSimulateCSFunction
fmiSimulateCS(str::fmi2Struct, tspan::Union{Tuple{Float64, Float64}, Nothing}=nothing, args...; kwargs...)

Start a simulation of the Co-Simulation FMU instance str.

Wrapper for fmi2SimulateCS.

FMI.fmiSimulateCSMethod
fmiSimulateCS(str::fmi3Struct, args...; kwargs...)

Start a simulation of the Co-Simulation FMU instance str.

Wrapper for fmi3SimulateCS.

FMI.fmiSimulateMEFunction
fmiSimulateME(str::Union{fmi2Struct,fmi3Struct}, tspan::Union{Tuple{Float64, Float64}, Nothing}=nothing;
                tolerance::Union{Real, Nothing} = nothing,
                dt::Union{Real, Nothing} = nothing,
                solver = nothing,
                customFx = nothing,
                recordValues::fmi2ValueReferenceFormat = nothing,
                saveat = nothing,
                x0::Union{AbstractArray{<:Real}, Nothing} = nothing,
                setup::Union{Bool, Nothing} = nothing,
                reset::Union{Bool, Nothing} = nothing,
                instantiate::Union{Bool, Nothing} = nothing,
                freeInstance::Union{Bool, Nothing} = nothing,
                terminate::Union{Bool, Nothing} = nothing,
                inputValueReferences::fmi2ValueReferenceFormat = nothing,
                inputFunction = nothing,
                parameters::Union{Dict{<:Any, <:Any}, Nothing} = nothing,
                dtmax::Union{Real, Nothing} = nothing,
                callbacks = [],
                showProgress::Bool = true,
                kwargs...)

Simulates a FMU instance for the given simulation time interval.

Arguments

More detailed: fmi2Struct = Union{FMU2, FMU2Component} More detailed: fmi3Struct = Union{FMU3, FMU3Instance}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.
  • str::FMU3: Mutable struct representing an FMU in the FMI 3.0 Standard.
  • str::FMU3Instance: Mutable struct represents a pointer to an FMU specific data structure that contains the information needed. Also in FMI 3.0 Standard.
  • tspan::Union{Tuple{Float64, Float64}, Nothing}=nothing: Sets the time span as a tuple or the default value from the model description is used.

Keywords

  • tolerance::Union{Real, Nothing} = nothing: Real number to set the tolerance for any OED-solver
  • dt::Union{Real, Nothing} = nothing: Real number to set the step size of the OED-solver. Defaults to an automatic choice if the method is adaptive. More Info: DifferentialEquations.jl Documentation
  • solver = nothing: Any Julia-supported OED-solver (default is Tsit5). More Info: DifferentialEquations.jl Documentation
  • customFx = nothing: [deperecated] Ability to give a custom state derivative function ẋ=f(x,t)
  • recordValues::fmi2ValueReferenceFormat = nothing: AbstractArray of variables (strings or variableIdentifiers) to record. Results are returned as DiffEqCallbacks.SavedValues
  • saveat = nothing: Time points to save values at (interpolated). More Info: DifferentialEquations.jl Documentation
  • x0::Union{AbstractArray{<:Real}, Nothing} = nothing: Stores the specific value of fmi2ScalarVariable containing the modelVariables with the identical fmi2ValueReference to the input variable vr (vr = vrs[i]). And is therefore passed within prepareSolveFMU to fmi2Set , to set the start state.
  • setup::Bool = true: Boolean, if FMU should be setup (default: setup=true)
  • reset::Union{Bool, Nothing} = nothing: Boolean, if FMU should be reset before simulation (default: reset:=auto)
  • instantiate::Union{Bool, Nothing} = nothing: Boolean value that decides whether to create a new instance of the specified fmu.
  • freeInstance::Union{Bool, Nothing} = nothing: Boolean value that determines whether to dispose of the given instance, unload the loaded model, and free the allocated memory and other resources allocated by the FMU interface functions.
  • terminate::Union{Bool, Nothing} = nothing: Boolean value that tells the FMU that the simulation run will be aborted.
  • inputValueReferences::fmi2ValueReferenceFormat = nothing: AbstractArray of input variables (strings or variableIdentifiers) to set at every simulation step
  • inputFunction = nothing: Function to retrieve the values to set the inputs to
  • parameters::Union{Dict{<:Any, <:Any}, Nothing} = nothing: Dictionary of parameter variables (strings or variableIdentifiers) and values (Real, Integer, Boolean, String) to set parameters during initialization
  • dtmax::Union{Real, Nothing} = nothing: Real number for setting maximum dt for adaptive timestepping for the ODE solver. The default values are package dependent. More Info: DifferentialEquations.jl Documentation
  • callbacks = []: custom callbacks to add.
  • showProgress::Bool = true: Boolean value that determines whether a progress bar is generated for a task
  • kwargs...: Further parameters of already defined functions solve(args..., kwargs...) from the library DifferentialEquations.jl

Returns

  • If keyword recordValues is not set, a struct of type ODESolution.
  • If keyword recordValues is set, a tuple of type (ODESolution, DiffEqCallbacks.SavedValues).

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.22]: 2.1.4 Inquire Platform and Version Number of Header Files
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions

See also fmi2SimulateME fmi2SimulateCS, fmi2Simulate, fmi2Struct, FMU2, FMU2Component.

FMI.fmiTerminateMethod

DEPRECATED fmiTerminate(str::fmi2Struct)

Informs the FMU that the simulation run is terminated, version independent.

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.

Returns

  • Returns a warning if str.state is not called in fmi2ComponentStateContinuousTimeMode or fmi2ComponentStateEventMode.
  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.23]: 2.1.6 Initialization, Termination, and Resetting an FMU
  • FMISpec2.0.2[p.18]: 2.1.3 Status Returned by Functions
FMI.fmiUnloadMethod
fmiUnload(fmu::Union{FMU2, FMU3})

Unloads the FMU and all its instances and frees the allocated memory.

Arguments

  • fmu::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • fmu::FMU3: Mutable struct representing a FMU and all it instantiated instances in the FMI 3.0 Standard.

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.22]: 2.1.4 Inquire Platform and Version Number of Header Files
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions

See also fmi2Unload, fmi3Unload.

FMICore.fmi2CancelStepMethod
fmi2CancelStep(fmu::FMU2)

Wrapper for fmi2CancelStep(c::FMU2Component) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2DoStepMethod
fmi2DoStep(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2DoStep(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2EnterContinuousTimeModeMethod
fmi2EnterContinuousTimeMode(fmu::FMU2)

Wrapper for fmi2EnterContinuousTimeMode(c::FMU2Component) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2EnterEventModeMethod
fmi2EnterEventMode(fmu::FMU2)

Wrapper for fmi2EnterEventMode(c::FMU2Component) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2EnterEventModeMethod

DEPRECATED fmi2EnterEventMode(str::fmi2Struct)

The model enters Event Mode from the Continuous-Time Mode and discrete-time equations may become active (and relations are not “frozen”).

Arguments

  • str::fmi2Struct: Representative for an FMU in the FMI 2.0.2 Standard.

More detailed: fmi2Struct = Union{FMU2, FMU2Component}

  • str::FMU2: Mutable struct representing a FMU and all it instantiated instances in the FMI 2.0.2 Standard.
  • str::FMU2Component: Mutable struct represents an instantiated instance of an FMU in the FMI 2.0.2 Standard.

Returns

  • status::fmi2Status: Return status is an enumeration of type fmi2Status and indicates the success of the function call.

More detailed:

  • fmi2OK: all well
  • fmi2Warning: things are not quite right, but the computation can continue
  • fmi2Discard: if the slave computed successfully only a subinterval of the communication step
  • fmi2Error: the communication step could not be carried out at all
  • fmi2Fatal: if an error occurred which corrupted the FMU irreparably
  • fmi2Pending: this status is returned if the slave executes the function asynchronously

Source

  • FMISpec2.0.2 Link: https://fmi-standard.org/
  • FMISpec2.0.2[p.16]: 2.1.2 Platform Dependent Definitions (fmi2TypesPlatform.h)
  • FMISpec2.0.2[p.16]: 2.1.3 Status Returned by Functions
  • FMISpec2.0.2[p.83]: 3.2.2 Evaluation of Model Equations
FMICore.fmi2EnterInitializationModeMethod
fmi2EnterInitializationMode(fmu::FMU2)

Wrapper for fmi2EnterInitializationMode(c::FMU2Component) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2ExitInitializationModeMethod
fmi2ExitInitializationMode(fmu::FMU2)

Wrapper for fmi2ExitInitializationMode(c::FMU2Component) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2FreeFMUstate!Method
fmi2FreeFMUstate!(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2FreeFMUstate!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2FreeInstance!Method
fmi2FreeInstance!(fmu::FMU2)

Wrapper for fmi2FreeInstance!(c::FMU2Component; popComponent::Bool = true) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2GetBoolean!Method
fmi2GetBoolean!(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetBoolean!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2GetDirectionalDerivative!Method
fmi2GetDirectionalDerivative!(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetDirectionalDerivative!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2GetInteger!Method
fmi2GetInteger!(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetInteger!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2GetReal!Method
fmi2GetReal!(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetReal!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2GetString!Method
fmi2GetString!(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetString!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2ResetMethod
fmi2Reset(fmu::FMU2)

Wrapper for fmi2Reset(c::FMU2Component; soft::Bool=false) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2SetBooleanMethod
fmi2SetBoolean(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SetBoolean(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2SetContinuousStatesMethod
fmi2SetContinuousStates(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SetContinuousStates(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2SetDebugLoggingMethod
fmi2SetDebugLogging(fmu::FMU2)

Wrapper for fmi2SetDebugLogging(c::FMU2Component) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2SetFMUstateMethod
fmi2SetFMUstate(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SetFMUstate(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2SetIntegerMethod
fmi2SetInteger(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SetInteger(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2SetRealMethod
fmi2SetReal(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SetReal(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2SetRealInputDerivativesMethod
fmi2SetRealInputDerivatives(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SetRealInputDerivatives(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2SetStringMethod
fmi2SetString(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SetString(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2SetTimeMethod
fmi2SetTime(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SetTime(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2SetupExperimentMethod
fmi2SetupExperiment(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SetupExperiment(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi2TerminateMethod
fmi2Terminate(fmu::FMU2)

Wrapper for fmi2Terminate(c::FMU2Component; soft::Bool=false) without a provided FMU2Component. (Component c gets selected from fmu)

FMICore.fmi3DoStep!Method
fmi3DoStep!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3DoStep!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3EnterConfigurationModeMethod
fmi3EnterConfigurationMode(fmu::FMU3)

Wrapper for fmi3EnterConfigurationMode(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3EnterContinuousTimeModeMethod
fmi3EnterContinuousTimeMode(fmu::FMU3)

Wrapper for fmi3EnterContinuousTimeMode(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3EnterEventModeMethod
fmi3EnterEventMode(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3EnterEventMode(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3EnterInitializationModeMethod
fmi3EnterInitializationMode(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3EnterInitializationMode(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3EnterStepModeMethod
fmi3EnterStepMode(fmu::FMU3)

Wrapper for fmi3EnterStepMode(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3EvaluateDiscreteStatesMethod

fmi3EvaluateDiscreteStates(fmu::FMU3)

Wrapper for fmi3EvaluateDiscreteStates(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3ExitConfigurationModeMethod
fmi3ExitConfigurationMode(fmu::FMU3)

Wrapper for fmi3ExitConfigurationMode(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3ExitInitializationModeMethod
fmi3ExitInitializationMode(fmu::FMU3)

Wrapper for fmi3ExitInitializationMode(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3FreeFMUState!Method
fmi3FreeFMUState!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3FreeFMUState!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3FreeInstance!Method
fmi3FreeInstance!(fmu::FMU3)

Wrapper for fmi3FreeInstance!(c::FMU3Instance; popInstance::Bool = true) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetAdjointDerivative!Method
fmi3GetAdjointDerivative!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetAdjointDerivative!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetBinary!Method
fmi3GetBinary!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetBinary!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetBoolean!Method
fmi3GetBoolean!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetBoolean!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetClock!Method
fmi3GetClock!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetClock!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetDirectionalDerivative!Method
fmi3GetDirectionalDerivative!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetDirectionalDerivative!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetFloat32!Method
fmi3GetFloat32!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetFloat32!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetFloat64!Method
fmi3GetFloat64!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetFloat64!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetInt16!Method
fmi3GetInt16!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetInt16!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetInt32!Method
fmi3GetInt32!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetInt32!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetInt64!Method
fmi3GetInt64!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetInt64!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetInt8!Method
fmi3GetInt8!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetInt8!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetString!Method
fmi3GetString!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetString!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetUInt16!Method
fmi3GetUInt16!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetUInt16!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetUInt32!Method
fmi3GetUInt32!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetUInt32!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetUInt64!Method
fmi3GetUInt64!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetUInt64!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3GetUInt8!Method
fmi3GetUInt8!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetUInt8!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3ResetMethod
fmi3Reset(fmu::FMU3)

Wrapper for fmi3Reset(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetBinaryMethod
fmi3SetBinary(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetBinary(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetBooleanMethod
fmi3SetBoolean(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetBoolean!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetClockMethod
fmi3SetClock(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetClock(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetContinuousStatesMethod
fmi3SetContinuousStates(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetContinuousStates(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetDebugLoggingMethod
fmi3SetDebugLogging(fmu::FMU3)

Wrapper for fmi3SetDebugLogging(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetFMUStateMethod
fmi3SetFMUState(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetFMUState(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetFloat32Method

fmi3SetFloat32(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetFloat32(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetFloat64Method
fmi3SetFloat64(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetFloat64(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetInt16Method
fmi3SetInt16(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetInt16(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetInt32Method
fmi3SetInt32(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetInt32(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetInt64Method
fmi3SetInt64(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetInt64(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetInt8Method
fmi3SetInt8(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetInt8(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetStringMethod
fmi3SetString(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetString(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetTimeMethod
fmi3SetTime(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetTime(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetUInt16Method
fmi3SetUInt16(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetUInt16(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetUInt32Method
fmi3SetUInt32(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetUInt32(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetUInt64Method
fmi3SetUInt64(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetUInt64(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3SetUInt8Method
fmi3SetUInt8(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SetUInt8(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3TerminateMethod
fmi3Terminate(fmu::FMU3)

Wrapper for fmi3Terminate(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMICore.fmi3UpdateDiscreteStatesMethod
fmi3UpdateDiscreteStates(fmu::FMU3)

Wrapper for fmi3UpdateDiscreteStates(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi2CompletedIntegratorStepMethod
fmi2CompletedIntegratorStep(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2CompletedIntegratorStep(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2DeSerializeFMUstateMethod
fmi2DeSerializeFMUstate(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2DeSerializeFMUstate(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2Get!Method
fmi2Get!(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2Get!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetMethod
fmi2Get(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2Get(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetBooleanMethod
fmi2GetBoolean(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetBoolean(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetContinuousStatesMethod
fmi2GetContinuousStates(fmu::FMU2)fmi2ins

Wrapper for fmi2GetContinuousStates(c::FMU2Component) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetDerivativesMethod
fmi2GetDerivatives(fmu::FMU2)

Wrapper for fmi2GetDerivatives(c::FMU2Component) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetDirectionalDerivativeMethod
fmi2GetDirectionalDerivative(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetDirectionalDerivative(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetEventIndicatorsMethod
fmi2GetEventIndicators(fmu::FMU2)

Wrapper for fmi2GetEventIndicators() without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetFMUstateMethod
fmi2GetFMUstate(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetFMUstate(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetIntegerMethod
fmi2GetInteger(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetInteger(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetJacobian!Method
fmi2GetJacobian!(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetJacobian!(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetJacobianMethod
fmi2GetJacobian(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetJacobian(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetNominalsOfContinuousStatesMethod
fmi2GetNominalsOfContinuousStates(fmu::FMU2)

Wrapper for fmi2GetNominalsOfContinuousStates(c::FMU2Component) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetRealMethod
fmi2GetReal(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetReal(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetRealOutputDerivativesMethod
fmi2GetRealOutputDerivatives(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetRealOutputDerivatives(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetStartValueMethod
fmi2GetStartValue(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetStartValue(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2GetStringMethod
fmi2GetString(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2GetString(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2NewDiscreteStatesMethod
fmi2NewDiscreteStates(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2NewDiscreteStates(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2SerializeFMUstateMethod
fmi2SerializeFMUstate(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SerializeFMUstate(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2SerializedFMUstateSizeMethod
fmi2SerializedFMUstateSize(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2SerializedFMUstateSize(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi2SetMethod
fmi2Set(fmu::FMU2, args...; kwargs...)

Wrapper for fmi2Set(c::FMU2Component, args...; kwargs...) without a provided FMU2Component. (Component c gets selected from fmu)

FMIImport.fmi3CompletedIntegratorStepMethod

fmi3CompletedIntegratorStep(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3CompletedIntegratorStep(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3DeSerializeFMUStateMethod
fmi3DeSerializeFMUState(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3DeSerializeFMUState(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3Get!Method
fmi3Get!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3Get!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetMethod
fmi3Get(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3Get(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetAdjointDerivativeMethod
fmi3GetAdjointDerivative(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetAdjointDerivative(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetBinaryMethod
fmi3GetBinary(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetBinary(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetBooleanMethod
fmi3GetBoolean(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetBoolean(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetClockMethod
fmi3GetClock(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetClock(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetContinuousStateDerivativesMethod

fmi3GetContinuousStateDerivatives(fmu::FMU3)

Wrapper for fmi3GetContinuousStateDerivatives(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetContinuousStatesMethod
fmi3GetContinuousStates(fmu::FMU3)

Wrapper for fmi3GetContinuousStates(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetDirectionalDerivativeMethod
fmi3GetDirectionalDerivative(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetDirectionalDerivative(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetEventIndicatorsMethod
fmi3GetEventIndicators(fmu::FMU3)

Wrapper for fmi3GetEventIndicators(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetFMUStateMethod
fmi3GetFMUstate(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetFMUstate(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetFloat32Method
fmi3GetFloat32(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetFloat32(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetFloat64Method
fmi3GetFloat64(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetFloat64(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetInt16Method
fmi3GetInt16(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetInt16(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetInt32Method
fmi3GetInt32(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetInt32(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetInt64Method
fmi3GetInt64(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetInt64(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetInt8Method
fmi3GetInt8(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetInt8(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetJacobian!Method
fmi3GetJacobian!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetJacobian!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetJacobianMethod
fmi3GetJacobian(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetJacobian(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetNominalsOfContinuousStatesMethod
fmi3GetNominalsOfContinuousStates(fmu::FMU3)

Wrapper for fmi3GetNominalsOfContinuousStates(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetNumberOfContinuousStatesMethod
fmi3GetNumberOfContinuousStates(fmu::FMU3)

Wrapper for fmi3GetNumberOfContinuousStates(c::FMU3Instance) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetStartValueMethod
fmi3GetStartValue(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetStartValue(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetStringMethod
fmi3GetString(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetString(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetUInt16Method
fmi3GetUInt16(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetUInt16(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetUInt32Method
fmi3GetUInt32(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetUInt32(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetUInt64Method
fmi3GetUInt64(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetUInt64(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3GetUInt8Method
fmi3GetUInt8(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3GetUInt8(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3SampleDirectionalDerivative!Method
fmi3SampleDirectionalDerivative!(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SampleDirectionalDerivative!(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3SampleDirectionalDerivativeMethod
fmi3SampleDirectionalDerivative(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SampleDirectionalDerivative(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3SerializeFMUStateMethod
fmi3SerializeFMUState(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SerializeFMUState(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3SerializedFMUStateSizeMethod
fmi3SerializedFMUStateSize(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3SerializedFMUStateSize(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)

FMIImport.fmi3SetMethod
fmi3Set(fmu::FMU3, args...; kwargs...)

Wrapper for fmi3Set(c::FMU3Instance, args...; kwargs...) without a provided FMU3Instance. (Instance c gets selected from fmu)