Giter VIP home page Giter VIP logo

fmi-standard's Introduction

FMI logo horizontal

Functional Mock-up Interface

The Functional Mock-up Interface (FMI) is a free standard that defines an interface to exchange dynamic models using a combination of XML files, binaries and C code. It’s supported by 170+ tools and maintained as a Modelica Association Project.

Releases and the latest development version of the specification are available on the FMI website.

Repository Structure

  • docs — sources of the specification document

  • headers — header files of the C-API

  • schema — XSD schema for the modelDescription.xml

  • CONTRIBUTING.adoc — info on contributing to the project and building the specification document

  • README.adoc — this document

Branches

  • main — development of the next release

  • v{2|3}.0.x — maintenance of the 2.0 and 3.0 releases

Layered Standards

The following layered standards are currently under development.

  • XCP — information for calibration and measurement

  • Network Communication — mapping of variables to buses

  • Structure — semantic grouping of variables

Code and documentation copyright © 2008-2011 the MODELISAR consortium and 2012-2024 the Modelica Association Project FMI. Code released under the 2-Clause BSD License. Docs released under Attribution-ShareAlike 4.0 International.

fmi-standard's People

Contributors

andreas-junghanns avatar antvl avatar beutlich avatar chrbertsch avatar clagms avatar cschulzetlk avatar dietmarw avatar gallleo avatar hsilm avatar izacharias avatar jbernalr avatar karlwernersson avatar klausschuch avatar make-ing avatar maplesoft-fmigroup avatar masoud-najafi avatar mblesken avatar nickbattle avatar oliverkotte avatar otronarp avatar petermeisrimelmodelon avatar pmai avatar ptaeuberds avatar rfranke avatar robbr48 avatar t-schenk avatar t-sommer avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

fmi-standard's Issues

Partition of FMI C header files

Reported by jvpeetz on 14 Feb 2011 10:19 UTC
I would like to propose to partition the header file (of Co-Simulation) "fmiFunctions.h" into two header files. One file, it could be called "fmiTypes.h", contains only type declarations (conveniently also function types). This file can be used for compiling a slave library, as well as for compiling a FMI master program which also needs the FMI function types. The other header file is called "fmiFunctions.h" as before and contains the function declarations which are only needed for a slave library. This file "includes" the file "fmiTypes.h" and can be used in the same way as the header file previously called "fmiFunctions.h".
The proposed files are attached to this ticket.
While at it, I also replaced an inline commentary started with "// .." by a
c-conform commentary "/* .. */".
The files have been tested with different c-compilers under GNU/Linux.
This partition should be applicable to the model exchange interface also.


Migrated-From: https://trac.fmi-standard.org/ticket/43

Make step events optional (or remove it from the 2.0 specification)

Modified by dietmarw on 19 Mar 2012 10:13 UTC
In the Model Exchange specification, step events are solver-related events, they are not related to the model. Introducing them in the FMI specification mixes two different unrelated levels. If we want to have a chance to import a FMU at Modelica level (i.e. at modeling levels) step events should be removed (or at least being optional) since there is no clean way to represent it at modeling level (all the workaround that could be proposed in Modelica only lead to a hack, not a mathematically well-defined representation of a FMU as an external model). The main consequence is that the "step Accepted" and "step In Progress" vertices of the state machines should be merged, and the fmiCompletedIntegratorStep function should not be mandatory any more to evaluate a FMU.

The proposed optionalCompletedIntegratorStep capability flag (draft 2.0 document, page 45) is a step in the good direction. In all cases, a model should not rely on such a capability to be correctly executed by an importing environment.


Reported by aviel on 18 Apr 2011 09:41 UTC
In the Model Exchange specification, step events are solver-related events, they are not related to the model. Introducing them in the FMI specification mixes two different unrelated levels. If we want to have a chance to import a FMU at Modelica level (i.e. at modeling levels) step events should be removed (or at least being optional) since there is no clean way to represent it at modeling level (all the workaround that could be proposed in Modelica only lead to a hack, not a mathematically well-defined representation of a FMU as an external model). The main consequence is that the "step Accepted" and "step In Progress" vertices of the state machines should be merged, and the fmiCompletedIntegratorStep function should not be mandatory any more to evaluate a FMU.

The proposed optionalCompletedIntegratorStep capability flag (draft 2.0 document, page 45) is a step in the good direction. In all cases, a model should not rely on such a capability to be correctly executed by an importing environment.


Migrated-From: https://trac.fmi-standard.org/ticket/53

Strings in attributes are normalized which gives problems with spaces

Reported by otter on 4 Jan 2010 21:36 UTC
Strings in xml-attributes seemed to be always normalized, independent of their underlying data type by discarding any leading and trailing space (#x20) characters, and by replacing sequences of space (#x20) characters by a single space (#x20) character
(see http://www.w3.org/TR/2000/WD-xml-2e-20000814#AVNormalize)

Therefore, it seems that the following attributes should be changed back from xs:string to xs:normalizedString (in order that, e.g., line breaks cannot be used):

!modelName
VendorAnnotations.Tool.name
VendorAnnotations.Tool.Annotation.name
TypeDefinitions.Type.name
TypeDefinitions.Type.EnumerationType.Item.name
ScalarVariable.name
ScalarVariable.<Type>.declaredType
DirectDependency.Name

There is one important issue: In Modelica it is possible to define a name with apostrophes and any character in between, such as 'strange name'. From a Modelica point of view the number of space characters matter. If used as an attribute, then the xml-parser will change this to 'strange name' and then name conflicts can occur. This could be fixed by introducing an escape character in strings, e.g.:

'short\ \ name' -> the same as 'short name'

The alternative would be to not use attributes at many places. However, the design would then be no longer so nice, and a lot of changes would be needed.


Migrated-From: https://trac.fmi-standard.org/ticket/31

define alignment structs and arrays for fmi

Reported by andreas.junghanns on 8 Jan 2010 22:15 UTC
We have not specified the alignment for structs and arrays in the fmi yet. This could allow compilers or users to define the alignment - that could lead to incompatible binaries.

Thus, I suggest to (re-)define the alignment policy:

#ifdef WIN32
#pragma pack(push,8)
#endif

struct A {
...
};

#ifdef WIN32
#pragma pack(pop)
#endif

I tested this and it works for Visual Studio and gcc.
Test attached.


Migrated-From: https://trac.fmi-standard.org/ticket/34

eventIndicatorsWithHysteresis

Modified by dietmarw on 19 Mar 2012 10:12 UTC
Here is a comment from Markus Friedrich to the FMI 2.0 draft:

The PDF defines an additional argument eventIndicatorsWithHysteresis for fmiInstantiateModel which miss-match the definition in fmiFunctions.h. Using this argument it will be possible (for the simulation environment) to turn off the FMU internal hysteresis for roots. According the last meeting only the FMU knows the correct hysteresis. Hence to avoid double adding of hysteresis the simulation environment should turn off their hysteresis for imported FMUs. The FMU should always include a hysteresis.

Possible solution: remove the eventIndicatorsWithHysteres argument.


Reported by otter on 7 Apr 2011 08:56 UTC
Here is a comment from Markus Friedrich to the FMI 2.0 draft:

The PDF defines an additional argument eventIndicatorsWithHysteresis for fmiInstantiateModel which miss-match the definition in fmiFunctions.h. Using this argument it will be possible (for the simulation environment) to turn off the FMU internal hysteresis for roots. According the last meeting only the FMU knows the correct hysteresis. Hence to avoid double adding of hysteresis the simulation environment should turn off their hysteresis for imported FMUs. The FMU should always include a hysteresis.

Possible solution: remove the eventIndicatorsWithHysteres argument.


Migrated-From: https://trac.fmi-standard.org/ticket/50

Support for non-Modelica enums

Modified by dietmarw on 19 Mar 2012 10:07 UTC
Section 3.2 Definition of a Type (fmiType) of "FMI for Model Exchange" says that EnumerationType has integer-valued attributes min and max, and a list of zero or more Items.
Comment in the corresponding UML diagram:
"First item has value=1, Second value has value=2, etc."

I guess this comment implies that the min attribute has value 1 (at least if there is at least 1 Item), and max is the number of Items. If so, the constraints for min max of an EnumerationType should be made explicit in the spec.

However, I propose to generalize the current rep in a backward compatible way to also support non Modelica enums, e.g. those that start from 0, or contain gaps and duplicate values.

Background: a customer used the FMI to also represent
control software compiled from C code. His example used an enum
that started from -2 (meaning 2nd reverse gear in this case)
and contained gaps.

The proposal is to fully support C enums.

  • Item defines an optional integer-valued attribute "value"
  • By default, enum vlaues start with 1, unless the first Item defines a different start
  • A value attribute in Item resets the value counter to the given value
  • min and max are constrained to be the extremal values of the enum defined this way

This would e.g. allow the encoding of the following C enum

enum e_tag{
      a, b, c, d=20, e, f, g=20, h
}var;

The names declared inside the enumeration are constants with int type. Their values are these:

a == 0
b == 1
c == 2
d == 20
e == 21
f == 22
g == 20
h == 21

This enum is of course ugly. But if we do not support such enums, it will be difficult to create automated conversion procedures from C to FMU. A tool could issue a warning here, but it should not silenty
use a different value encoding (error prone) or force the user to stick to Modelica enum rules in their C code (difficult if he uses a code generator).


Reported by jakob on 25 Dec 2010 13:33 UTC
Section 3.2 Definition of a Type (fmiType) of "FMI for Model Exchange" says that EnumerationType has integer-valued attributes min and max, and a list of zero or more Items.
Comment in the corresponding UML diagram:
"First item has value=1, Second value has value=2, etc."

I guess this comment implies that the min attribute has value 1 (at least if there is at least 1 Item), and max is the number of Items. If so, the constraints for min max of an EnumerationType should be made explicit in the spec.

However, I propose to generalize the current rep in a backward compatible way to also support non Modelica enums, e.g. those that start from 0, or contain gaps and duplicate values.

Background: a customer used the FMI to also represent
control software compiled from C code. His example used an enum
that started from -2 (meaning 2nd reverse gear in this case)
and contained gaps.

The proposal is to fully support C enums.

  • Item defines an optional integer-valued attribute "value"
  • By default, enum vlaues start with 1, unless the first Item defines a different start
  • A value attribute in Item resets the value counter to the given value
  • min and max are constrained to be the extremal values of the enum defined this way

This would e.g. allow the encoding of the following C enum

enum e_tag{
      a, b, c, d=20, e, f, g=20, h
}var;

The names declared inside the enumeration are constants with int type. Their values are these:

a == 0
b == 1
c == 2
d == 20
e == 21
f == 22
g == 20
h == 21

This enum is of course ugly. But if we do not support such enums, it will be difficult to create automated conversion procedures from C to FMU. A tool could issue a warning here, but it should not silenty
use a different value encoding (error prone) or force the user to stick to Modelica enum rules in their C code (difficult if he uses a code generator).


Migrated-From: https://trac.fmi-standard.org/ticket/42

New attribute Capabilities within ModelAttributes

Reported by otter on 6 Dec 2009 10:06 UTC
Peter Nilsson suggested to introduce a new attribute Capabilities within ModelAttributes in order to define what capabilities the model supports in order to ease the implementation of the environment. Currently proposed attributes inside Capabilities:

  • ToleranceControlled = false/true (default: false)
    = true: The model contains parts that are solved iteratively. The iteration will be solved with a precision that is higher as the relative tolerance defined with meInitialize.

  • IntermediateEventResults = false/true (default: false)
    = true: The model is generated in a way, that flag "intermediateResults" in meEventUpdate has an effect. If false, event iteration in the model will always continue until completion and will only then return.


Migrated-From: https://trac.fmi-standard.org/ticket/20

fmiDoStep: termination by model

Reported by peter.nilsson on 9 Mar 2010 07:41 UTC
In the FMI model execution interface, the "terminateSimulation" was added to the fmiEventInfo struct to handle the case when the model itself decides to terminate. We need a similar way to handle this here. In particular, the time for termination should be propagated.


Migrated-From: https://trac.fmi-standard.org/ticket/37

Undefined value reference (needed for states)

Reported by otter on 4 Dec 2009 08:07 UTC
In the meModelTypes.h file the following definition should be added:

#include <limits.h>
  ...
#define meUndefinedValueReference UINT_MAX

i.e., the largest value of "unsigned int" is defined to be a special value to characterize an undefined value reference. With this definition, meGetContinuousStates should be extended with the following sentence:
If the provider of a model hides the states, no internal variables are defined in the Model Variable file. In this case a meValueReference of "meUndefinedValueReference" is returned (= the maximum value of unsigned int).

Alternatively, the "#define" is not needed and "UINT_MAX" is directly used in meGetContinuousStates.


Migrated-From: https://trac.fmi-standard.org/ticket/12

meEventInfo.statesChanged is dual and could be split

Reported by peter.nilsson on 16 Dec 2009 13:57 UTC
The current meEventInfo.statesChanged shall be set in two occasions:

  1. If the association of the continuous states to the variables has changed.
  2. If any value has changed.

This complicates the semantics and hence the API descritpions. It may also cause unnecessary fetching when only one of the two are cases occur.

Suggestion:
Break out a new varaible meEventInfo.stateValuesChanged for the latter purpose.


Migrated-From: https://trac.fmi-standard.org/ticket/27

Version as decimal number and not as string

Modified by dietmarw on 19 Mar 2012 10:11 UTC
Here is a comment from Markus Friedrich to the FMI 2.0 draft:

The type of the "version" attribute in miModelDescription.xsd has been changed from string to decimal. Now it would not be possible to define a version e.g. "1.4.2", since this is not a decimal representation. Possible solution: Use string as before.


Reported by otter on 7 Apr 2011 08:22 UTC
Here is a comment from Markus Friedrich to the FMI 2.0 draft:

The type of the "version" attribute in miModelDescription.xsd has been changed from string to decimal. Now it would not be possible to define a version e.g. "1.4.2", since this is not a decimal representation. Possible solution: Use string as before.


Migrated-From: https://trac.fmi-standard.org/ticket/47

Alternative mode allowing malloc/calloc

Modified by dietmarw on 19 Mar 2012 10:05 UTC
The restriction of not using built in malloc or calloc may be very limiting due to external libraries that normally hardcode usage of these functions. To comply with the rule the FMI implementor is left with either not using external libraries or manipulating them.
Considering this and that is it often ok to rely on built in malloc/calloc, there should be an option for the FMU to comply or not to comply with the restriction. Perhaps it could be specified by a new attribute in the model description.

This is even more relevant for the co-simulation interface where built in integration typically relies on external libraries.


Reported by peter.nilsson on 19 May 2010 13:14 UTC
The restriction of not using built in malloc or calloc may be very limiting due to external libraries that normally hardcode usage of these functions. To comply with the rule the FMI implementor is left with either not using external libraries or manipulating them.
Considering this and that is it often ok to rely on built in malloc/calloc, there should be an option for the FMU to comply or not to comply with the restriction. Perhaps it could be specified by a new attribute in the model description.

This is even more relevant for the co-simulation interface where built in integration typically relies on external libraries.


Migrated-From: https://trac.fmi-standard.org/ticket/40

VariableNamingConvention should be precisely defined

Reported by otter on 6 Dec 2009 09:58 UTC
In order that an environment can make use of the VariableNamingConvention, not only the tool name should be given, but also the naming convention of this tool should be precisely defined (especially, the separator of hierarchies).

Currently, only Modelica is defined. Additional useful naming conventions would be "Simpack" and "Sfunction".


Migrated-From: https://trac.fmi-standard.org/ticket/19

Wrong argument in fmiStepFinished

Modified by dietmarw on 19 Mar 2012 10:12 UTC
Here is a comment from Markus Friedrich to the FMI 2.0 draft:

Wrong argument in fmiStepFinished: The handle argument fmiComponent should be fmiComponentEnvironment (same problem as for the fmiCallbackLogger function discussed at the last meeting). Possible solution: change the type to fmiComponentEnvironment.


Reported by otter on 7 Apr 2011 08:49 UTC
Here is a comment from Markus Friedrich to the FMI 2.0 draft:

Wrong argument in fmiStepFinished: The handle argument fmiComponent should be fmiComponentEnvironment (same problem as for the fmiCallbackLogger function discussed at the last meeting). Possible solution: change the type to fmiComponentEnvironment.


Migrated-From: https://trac.fmi-standard.org/ticket/49

Nominal values for event indicators

Reported by otter on 4 Dec 2009 16:19 UTC
Hysteresis has to be added to event indicators (see description in new appendix B.1). According to the FMI specification, this has to be performed in the simulation environment. This requires a selection of an appropriate "epsilon". The "epsilon" states when a particular event indicator "z" is "small". However, there is not enough information available to set the "epsilon" in a meaningful way.

One approach could be to add an optional "nominal" value for event indicators in the xml file (a vector of Reals with nz elements). It is then possible by the simulation environment to select an appropriate epsilon, depending, e.g., on the integrator tolerance.

If an event indicator is closely related to a variable (such as x > 0; select nominal value of "x" as nominal value of event indicator), then a tool can deduce the nominal value. Otherwise, a nominal value of one can be used. If this is important, a modeller can introduce an auxiliary variable for the expression comprising an event indicator and provide a nominal value for this auxiliary variable.


Migrated-From: https://trac.fmi-standard.org/ticket/16

Not possible to terminate simulation from the FMU

Reported by otter on 6 Dec 2009 19:07 UTC
According to my understanding, it is currently not possible to stop the simulation from the FMU side. E.g. in Modelica one could write:

when x < 0 then
  terminate("Terminated since ground reached");
end when;

This can currently not be translated to FMI. Proposal:

add a new flag to meEventInfo to state that a simulation shall be stopped after this event:

typedef struct{
   meBoolean finished;
   meBoolean statesChanged;
   meBoolean terminateSimulation;   // new flag
   meReal    Tnext;
} meEventInfo;


Migrated-From: https://trac.fmi-standard.org/ticket/22

fmiBoolean changed from char to int

Modified by dietmarw on 19 Mar 2012 10:11 UTC
Here is a comment from Markus Friedrich to the FMI 2.0 draft:

fmiBoolean in fmiPlatformTypes.h has been changed from char to int, but in the last meeting there was consens not to change this (also the PDF has changed).

Possible solution: Use char for fmiBoolean as done by all C++ compilers.


Reported by otter on 7 Apr 2011 08:34 UTC
Here is a comment from Markus Friedrich to the FMI 2.0 draft:

fmiBoolean in fmiPlatformTypes.h has been changed from char to int, but in the last meeting there was consens not to change this (also the PDF has changed).

Possible solution: Use char for fmiBoolean as done by all C++ compilers.


Migrated-From: https://trac.fmi-standard.org/ticket/48

Unique identifier of variable

Reported by otter on 4 Dec 2009 10:27 UTC
There have been discussions about the unique identifier of variables in FMI. This shall be made clearer in the FMI specification:

  • ScalarVariableName uniquely identifies a variable (this string must be unique between all ScalarVariableNames and is used to uniquely identify a variable in the xml file).
  • The variables on the xml-file are defined in a particular sequence. This sequence number identifies a variable uniquely and allows an O(1) access of variables in a dictionary of the environment in which an FMU is called.

ValueReference is designed to access variable values in the FMI-C functions. It is a secret of the modeling environment that generates the FMI-C functions, in order that the modeling environments has no restrictions how to generate code and how to access variable values in the C-functions in the most appropriate way. Whether or not the "value reference" is unique, is a secret of the modeling environment that generated the FMI code. The only guarantee is that ValueReference is unique for a particular data type (Real, Integer/Enumeration, Boolean, String).


Migrated-From: https://trac.fmi-standard.org/ticket/15

location of time events

Reported by mauss on 4 Oct 2009 13:47 UTC
Must the current time be *exactly* set to Tnext as returned by meInitialize or previous meEventUpdate before calling meEventUpdate? Or is there an eps allowed? If yes, what is the tolerated eps?


Migrated-From: https://trac.fmi-standard.org/ticket/6

Wrong argument passed to logger callback

Modified by dietmarw on 19 Mar 2012 10:05 UTC

The logger callback is currently defined as

void logger(fmiComponent c, fmiString instanceName, fmiStatus status,
      fmiString category, fmiString message, ...);

The simulation environment that implements the logger is responsible for substituting references such as #r1365# in mesage by variable names. To do this, the environment needs to access the XML file. The bug is that the logger is only called with fmiComponent c as argument, which is a FMU internal handle that does not help the simulation envrionment to access the XML file.

The simulation environment would need to get its own representation of the FMU here, e.g. a pointer to the AST of the XML file. The simulation environment should pass its own rep. of an FMU instance when setting the callback functions, and the logger must be called by the model with this pointer.

A fairly backward compatible fix would be: Add a fourth field to fmiCallbackFunctions:

typedef struct {
     fmiCallbackLogger         logger;
     fmiCallbackAllocateMemory allocateMemory;
     fmiCallbackFreeMemory     freeMemory;
     fmiComponent              modelInstance; <<< NEW!
} fmiCallbackFunctions;

During simulation, the FMU calls the logger with the specified modelInstance (e.g. a handle to the XML file).


Reported by jakob on 6 Sep 2010 10:07 UTC

The logger callback is currently defined as

void logger(fmiComponent c, fmiString instanceName, fmiStatus status,
      fmiString category, fmiString message, ...);

The simulation environment that implements the logger is responsible for substituting references such as #r1365# in mesage by variable names. To do this, the environment needs to access the XML file. The bug is that the logger is only called with fmiComponent c as argument, which is a FMU internal handle that does not help the simulation envrionment to access the XML file.

The simulation environment would need to get its own representation of the FMU here, e.g. a pointer to the AST of the XML file. The simulation environment should pass its own rep. of an FMU instance when setting the callback functions, and the logger must be called by the model with this pointer.

A fairly backward compatible fix would be: Add a fourth field to fmiCallbackFunctions:

typedef struct {
     fmiCallbackLogger         logger;
     fmiCallbackAllocateMemory allocateMemory;
     fmiCallbackFreeMemory     freeMemory;
     fmiComponent              modelInstance; <<< NEW!
} fmiCallbackFunctions;

During simulation, the FMU calls the logger with the specified modelInstance (e.g. a handle to the XML file).


Migrated-From: https://trac.fmi-standard.org/ticket/41

problems with header files

Reported by mauss on 4 Jan 2010 09:38 UTC
The .h files currently checked in (rev 120) have several bugs
in fmiModelFunctions.h

  • Rename macro fmiGetModelFunctionsVersion to fmiGetVersion and
  • Rename macro fmiModelFunctionsVersion to fmiVersion
  • Replace fmiModel by fmiComponent in decl of fmiInstantiateModel
    in fmiModelTypes.h
  • Rename meModelTypes_h to fmiModelTypes_h
    I propose that I check in the corrected versions that I have tested with GCC and VC9.0, ok?

Migrated-From: https://trac.fmi-standard.org/ticket/28

Flaw with nominal values

Reported by otter on 6 Dec 2009 21:31 UTC
The "nominal" attribute is used to define, e.g., absolute tolerances for the integrator. As it is defined currently, it must be a "literal". In many cases, it might be useful to set the nominal value as function of a parameter. The same holds for "min" and "max" values. Furthermore, a tool might deduce nominal values via equations, e.g. if "a = b" and "b" has a nominal value but not "a", then "a.nominal := b.nominal" might be deduced. This means when the nominal value of "b" is changed, then the nominal value of "a" should also change. However, this cannot be expressed with the current schema.

To support such dependencies would require to provide C-functions to inquire nominal, min, and max values. However, this makes the interfaces more complicated. "min" and "max" are not so critical because dependent min/max-values could be checked inside the C-functions. However, for "nominal" this is not possible, because the simulation environment needs the nominal values. Furthermore, also the model might need nominal values, if iterative solvers are used inside the model. The requirement ist:

  1. Change nominal values in the interactive environment (e.g. via parameters, if a nominal value is computed from a parameter)
  2. Compute the nominal values of all variables
  3. Provide these nominal values to the C-functions

Seems quite complicated.

An ODE integrator needs an absolute tolerance for the continuous states. This can be calculated from the relative tolerance and from the nominal value. However, continuous states are not directly associated to any variable and therefore in the current FMI interface there is no way to define absolute tolerances in the integrator.

Solution proposal:

  1. All nominal values defined in the fmi-file must be reported to the FMU with a new "setNominal" function before meInitialize is called (alternatively, remove "nominal" from the xml-file attributes and have them pre-defined in the FMU).
  2. Provide a new function "getNominalOfContinuousStates" to inquire the nominal values from the continuous states (after meInitialize and after meEventUpdate).

Probably, it is simplest in version 1.0 to remove "nominal" from the xml schema and only provide (2), i.e., a function to inquire the nominal values of the continuous states from the FMU.


Migrated-From: https://trac.fmi-standard.org/ticket/23

Connecting discrete FMUs is ambiguous

Modified by dietmarw on 19 Mar 2012 09:28 UTC
When FMUs are connected, there is an ambiguity for discrete signals. There are several semantics possible:

  1. According to Modelica:
    Discrete signals are instantaneously communicated, i.e., the output of an FMU can be utilized as input of the connected FMU at the same event instant. This may lead to algebraic loops between FMUs. In Modelica one has to explicitly model the delay (either infinitesimal delay or a real delay).
  2. According to VHDL-AMS:
    There is always an infinitesimal delay at the input: all outputs are computed from the last known input values. Then an event iteration is started and the output computed in the last event iteration is used as input for the next event iteration.
  3. According to embedded systems:
    There is a delay of one event instant: all outputs are computed from the input values of the previous event instant.

This issue can probably be fixed by introducing a new attribute, e.g., "ConnectionSemantics", that defines the behavior of discrete input variables: "immediate" (case 1 above), "lastIterate" (case 2 above), "delayed" (case 3 above).


Reported by otter on 4 Dec 2009 21:08 UTC
When FMUs are connected, there is an ambiguity for discrete signals. There are several semantics possible:

  1. According to Modelica:
    Discrete signals are instantaneously communicated, i.e., the output of an FMU can be utilized as input of the connected FMU at the same event instant. This may lead to algebraic loops between FMUs. In Modelica one has to explicitly model the delay (either infinitesimal delay or a real delay).
  2. According to VHDL-AMS:
    There is always an infinitesimal delay at the input: all outputs are computed from the last known input values. Then an event iteration is started and the output computed in the last event iteration is used as input for the next event iteration.
  3. According to embedded systems:
    There is a delay of one event instant: all outputs are computed from the input values of the previous event instant.

This issue can probably be fixed by introducing a new attribute, e.g., "ConnectionSemantics", that defines the behavior of discrete input variables: "immediate" (case 1 above), "lastIterate" (case 2 above), "delayed" (case 3 above).


Migrated-From: https://trac.fmi-standard.org/ticket/17

Problems in section 2.10.Example

Reported by torstenblochwitz on 6 May 2010 09:47 UTC
We should add a statement in section 2.10 which use case is demonstrated here. It seems to be a kind of a "stand alone FMU" which is stimulated by some inputs. If the demonstrated use case is more complex (in other words: if the enclosing model is more complex) the following points are missing:

  1. In the event iteration loop the following call is missing before M_meEventUpdate(...):
    M_fmiSetReal(...)//set inputs, the enclosing model could have change them
  2. The event iteration does not necessarily finish when the FMU returns eventInfo.iterationConverged=fmiTrue. The enclosing model may require the continuation of event iteration

Both points are also not very obvious in the state machine.

Independent from the use case, the following thing should be changed:
The two if clauses after the event iteration loop should be inside the loop. The actual code reacts on changes of state values only if it happens in the last M_fmiEventUpdate call.


Migrated-From: https://trac.fmi-standard.org/ticket/39

causality and variability attribute

Modified by dietmarw on 19 Mar 2012 10:01 UTC
I wonder why we have chosen parameter as variability and not as causality attribute. May be I forgot the reason.
If we would use it as causality attribut (which would be more logical for me) we could use the variability attribute to indicate parameters which can be changed after fmiInitialize in a later version.


Reported by torstenblochwitz on 6 Jan 2010 08:14 UTC
I wonder why we have chosen parameter as variability and not as causality attribute. May be I forgot the reason.
If we would use it as causality attribut (which would be more logical for me) we could use the variability attribute to indicate parameters which can be changed after fmiInitialize in a later version.


Migrated-From: https://trac.fmi-standard.org/ticket/33

typos in FMI Spec. 0.95

Modified by Peter Nilsson on 5 Oct 2009 14:32 UTC
In the pdf document, correct

  • Förderkennzeichen: ???).
  • "Verweisquelle nicht gefunden" in Glossary and elsewhere
  • fig 2: missing superscript '-' for m
  • sec 2.4: "and that set de." ?
  • consistent (and correct) articles in front of FMU (it must be: "an FMU").
  • figure 4 caption: this is more efficient as than a state event
  • 3.6. startUsage enum value: fixed. This is called init in ME interface.

Modified by anonymous on 5 Oct 2009 12:49 UTC
In the pdf document, correct

  • Förderkennzeichen: ???).
  • "Verweisquelle nicht gefunden" in Glossary and elsewhere
  • fig 2: missing superscript '-' for m
  • sec 2.4: "and that set de." ?
  • consistent (and correct) articles in front of FMU (it must be: "an FMU").
  • figure 4 caption: this is more efficient as than a state event

Modified by andreas.junghanns on 4 Oct 2009 18:17 UTC
In the pdf document, correct

  • Förkennzeichen: ???).
  • "Verweisquelle nicht gefunden" in Glossary and elsewhere
  • fig 2: missing superscript '-' for m
  • sec 2.4: "and that set de." ?
  • consistent (and correct) articles in front of FMU (it must be: "an FMU").

Reported by mauss on 4 Oct 2009 13:52 UTC
In the pdf document, correct

  • Förderkennzeichen: ???).
  • "Verweisquelle nicht gefunden" in Glossary and elsewhere
  • fig 2: missing superscript '-' for m
  • sec 2.4: "and that set de." ?

Migrated-From: https://trac.fmi-standard.org/ticket/8

Logging in ME interface

Modified by dietmarw on 19 Mar 2012 10:04 UTC
The current log mechanism (meCallbackFunctions) emulates a log level by combining meStatus and a parameter loggingOn. This has disadvantages:

  • meStatus is not strictly leveled from a logging perspective (and should not have to be). E.g. which of meDiscard or meWarning should require a higher log level? In particular the draft says in 2.3 that meDiscard logs should only be showed when loggingOn = meTrue, but says nothing about meWarning.

  • The use of loggingOn is less powerful than real log levels and also confusing. E.g. as described in the previous item it is not clear from the draft which statuses should be affected by logginOn.

Suggestion:

  1. Introduce (same as Java's log levels):

typedef enum {
meLogTrace,
meLogDebug,
meLogInfo,
meLogWarning,
meLogError,
meLogFatal
} meLogLevel.

  1. Replace loggingOn parameter in meInstantiateModel with meLogLevel, i.e. instead specify the required log level for logging messages to be shown.

  2. Replace meSetDebugLogging with meSetLogLevel(meModel m, meLogLevel level).

  3. Replace meStatus parameter with meLogLevel parameter in logger function. The message is logged iff the log level is as least as high as the required log level.

Another issue is the purpose of the category parameter to function logger. From the draft in 2.4: "The meaning of category is defined by the modeling environment that generated the model code". How such a "meaning" can be useful for the simulating environment needs to be clarified. And will it still be useful if above suggestion with log levels is adopted?


Reported by peter.nilsson on 5 Oct 2009 12:14 UTC
The current log mechanism (meCallbackFunctions) emulates a log level by combining meStatus and a parameter loggingOn. This has disadvantages:

  • meStatus is not strictly leveled from a logging perspective (and should not have to be). E.g. which of meDiscard or meWarning should require a higher log level? In particular the draft says in 2.3 that meDiscard logs should only be showed when loggingOn = meTrue, but says nothing about meWarning.

  • The use of loggingOn is less powerful than real log levels and also confusing. E.g. as described in the previous item it is not clear from the draft which statuses should be affected by logginOn.

Suggestion:

  1. Introduce (same as Java's log levels):

typedef enum {
meLogTrace,
meLogDebug,
meLogInfo,
meLogWarning,
meLogError,
meLogFatal
} meLogLevel.

  1. Replace loggingOn parameter in meInstantiateModel with meLogLevel, i.e. instead specify the required log level for logging messages to be shown.

  2. Replace meSetDebugLogging with meSetLogLevel(meModel m, meLogLevel level).

  3. Replace meStatus parameter with meLogLevel parameter in logger function. The message is logged iff the log level is as least as high as the required log level.

Another issue is the purpose of the category parameter to function logger. From the draft in 2.4: "The meaning of category is defined by the modeling environment that generated the model code". How such a "meaning" can be useful for the simulating environment needs to be clarified. And will it still be useful if above suggestion with log levels is adopted?


Migrated-From: https://trac.fmi-standard.org/ticket/9

meEventUpdate and discrete inputs

Reported by mauss on 4 Oct 2009 13:42 UTC
The mathe. description says: "The non-real (input) variables change
their values only at events." Who generates these events? The FMU
could use event indicators to detect changes of discrete input
variables. Alternatively, the environment could by responsible
for calling meEventUpdate after having changed a discrete input
using meSetBoolean/Integer/String. What is the policy here?


Migrated-From: https://trac.fmi-standard.org/ticket/5

zip-file extension for an FMU

Reported by otter on 4 Dec 2009 08:04 UTC
All files of an FMU are stored in a zip-file. There are two conflicting goals for the extension:

  1. The user should see at once, that he can inspect the details of the file by unzipping the file (= use extension ".zip").
  2. The user should easily identify that the file is a FMU (= use extension ".fmu").

An alternative might be to combine both zip and fmu in the extension. E.g. ".fmu.zip" or ".fmu_zip" or "fzip".

My plan is to use the latter in the document ".fmu_zip".


Migrated-From: https://trac.fmi-standard.org/ticket/11

Add Function fmiResetModel(...) to FMI for Model Exchange

Reported by torstenblochwitz on 6 Apr 2011 06:46 UTC
FMI for Co-Simulation provides an fmiResetSlave function. It allows to restart a simulation (call fmiInitialize(), fmiDoStep(..)...) without freeing (fmiFreeSlaveInstance) and reinstantiation (fmiInstantiateSlave) before.
For some applications (e.g. model predictive control, where a model is repeatedly simulated some steps into future) such a function would be useful for FMI for Model Exchange too.


Migrated-From: https://trac.fmi-standard.org/ticket/45

Variability, Start, and StartUsage are too complicated

Reported by otter on 6 Dec 2009 07:24 UTC
The attributes Variability, Start and StartUsage are too complicated and it seems difficult to precisely define them. The reason is that all these attributes define part of the initialization.

It is proposed to simplify this considerably, by defining the variability (= "when a variable changes its value") and initialization in different attributes:

Variability defines when a variable changes its value:

  • constant:
    The value of the variable is fixed and
    does not change.

  • parameter:
    The value of the variable does not
    change after initialization (after meInitialize was called).

  • discrete:
    The value of the variable only
    changes during initialization and at event instants
    (value changes are only performed in calls to meInitialize
    and meEventUpdate).

  • continuous:
    No restrictions on value changes
    (the value can change at any time).
    Only a variable of DataType = "Real" can be "continuous".

Start defines the variable values that can be changed before initialization and that define the initialization problem, eventually together with additional initial equations defined in the C-functions. A variable without a "Start" attribute definition, cannot be initialized from the simulation environment. A "constant" variable is not allowed to have a "Start" attribute.

StartUsage is an enumeration that defines the meaning of "Start". This attribute is only allowed if "Start" is also present. "StartUsage" has the following allowed values:

  • Fixed:
    "Start" is an initial value of a variable,
    i.e., after initialization the variable has this value
    (at least up to a certain numerical precision).
    This is the default.

  • Guess:
    "Start" is a guess value for the variable
    that is used as iteration variable during initialization.
    After initialization, the variable can have a different value.


Migrated-From: https://trac.fmi-standard.org/ticket/18

Access resource files by FMI-ME FMUs

Modified by dietmarw on 19 Mar 2012 10:12 UTC
The co-simulation instantiation function provides an argument fmiLocation, but the model exchange instantiation function (fmiInstantiateModel) dose not provide such a parameter. Hence the loaded DLL/so dose not know where the FMU is located and therefore cannot e.g. load files placed in the resources directory of the FMU.

Giving fmiInstantiateModel a fmiLocation parameter solves this problem, but each instance has to unpack the FMU which will be mostly already unpacked ones by the simulation environment.
If the URI scheme "file://" is also allowed to specify a directory which contains the unzipped FMU this problem can also be solved.


Reported by MFriedrich on 8 Apr 2011 10:30 UTC
The co-simulation instantiation function provides an argument fmiLocation, but the model exchange instantiation function (fmiInstantiateModel) dose not provide such a parameter. Hence the loaded DLL/so dose not know where the FMU is located and therefore cannot e.g. load files placed in the resources directory of the FMU.

Giving fmiInstantiateModel a fmiLocation parameter solves this problem, but each instance has to unpack the FMU which will be mostly already unpacked ones by the simulation environment.
If the URI scheme "file://" is also allowed to specify a directory which contains the unzipped FMU this problem can also be solved.


Migrated-From: https://trac.fmi-standard.org/ticket/51

two representations of variable names in XML

Modified by dietmarw on 19 Mar 2012 10:04 UTC
There are currently two different ways to represent a variable name in ModelDescription.xml. Is there a reason not to use just one scheme here? Example:

  <ScalarVariable name="y23" valueReference="1" causality="output">
     <Real/>
     <DirectDependency>
        <Name>a.b</Name>
        <Name>a[1]</Name>
     </DirectDependency>      
  </ScalarVariable> 

Note the different representation of the variable names "y23", "a.b", and "a[1]". It would be more uniform to represent this as

  <ScalarVariable name="y23" valueReference="1" causality="output">
     <Real/>
     <DirectDependency>
        <Input name="a.b" />
        <Input name="a[1]" />
     </DirectDependency>      
  </ScalarVariable> 

To implement this, replace in fmiScalarVarable.xsd

 <xs:element name="Name" type="xs:string" minOccurs="0">
    <xs:annotation> ... </xs:annotation>
 </xs:element>

by

  <xs:element name="Input">
    <xs:annotation> ...  </xs:annotation>
    <xs:complexType>
      <xs:attribute name="name" type="xs:string" use="required"/>
    </xs:complexType>
  </xs:element>

Reported by jakob on 14 Jan 2010 10:00 UTC
There are currently two different ways to represent a variable name in ModelDescription.xml. Is there a reason not to use just one scheme here? Example:

  <ScalarVariable name="y23" valueReference="1" causality="output">
     <Real/>
     <DirectDependency>
        <Name>a.b</Name>
        <Name>a[1]</Name>
     </DirectDependency>      
  </ScalarVariable> 

Note the different representation of the variable names "y23", "a.b", and "a[1]". It would be more uniform to represent this as

  <ScalarVariable name="y23" valueReference="1" causality="output">
     <Real/>
     <DirectDependency>
        <Input name="a.b" />
        <Input name="a[1]" />
     </DirectDependency>      
  </ScalarVariable> 

To implement this, replace in fmiScalarVarable.xsd

 <xs:element name="Name" type="xs:string" minOccurs="0">
    <xs:annotation> ... </xs:annotation>
 </xs:element>

by

  <xs:element name="Input">
    <xs:annotation> ...  </xs:annotation>
    <xs:complexType>
      <xs:attribute name="name" type="xs:string" use="required"/>
    </xs:complexType>
  </xs:element>

Migrated-From: https://trac.fmi-standard.org/ticket/35

Unit Handling

Modified by dietmarw on 19 Mar 2012 10:11 UTC
Here is a comment from Markus Friedrich to the proposed improvement of units in the FMI 2.0 draft.

The derivedUnit attribute in the XML file (fmiUnit.xsd) may contain "user defined base units". Doing so, it would not be possible the compare the units between two FMUs using different "user defined base units".

Possible solution: Allow only SI Base Units in derivedUnit.


Reported by otter on 7 Apr 2011 08:12 UTC
Here is a comment from Markus Friedrich to the proposed improvement of units in the FMI 2.0 draft.

The derivedUnit attribute in the XML file (fmiUnit.xsd) may contain "user defined base units". Doing so, it would not be possible the compare the units between two FMUs using different "user defined base units".

Possible solution: Allow only SI Base Units in derivedUnit.


Migrated-From: https://trac.fmi-standard.org/ticket/46

clarify lifetime of strings

Reported by mauss on 4 Jan 2010 11:18 UTC
The life time of strings passed as arguments need to be clarified.
Proposal:

fmiInstantiateModel. Add the sentence:
"The string-valued arguments instanceName and GUID passed to the FMU are valid during the entire lifetime of the instance. So the FMU does not need to create a copy of these strings to use it later, e.g. when creating log messages."

function logger. Add the sentence:
"All string-valued arguments passed by the FMU to the logger may be deallocated by the FMU directly after fmiCallbackLogger returns. The environment must therefor create copies of these strings if it needs to access these strings later."

fmiSetString: Add the sentence:
"All strings passed to the FMU in the value[] array are valid during the entire lifetime of the instance."

fmiGetString: Add the sentence:
"All strings returned by the FMU in the value[] array may be deallocated by the FMU directly after fmiGetString returns.


Migrated-From: https://trac.fmi-standard.org/ticket/29

Inquire capabilities of an FMU

Reported by otter on 4 Dec 2009 08:17 UTC
Add a function

meStatus meGetCapabilites(meModel m, meCapabilities* capabilities);

and some struct meCapabilites defining what the FMU supports. E.g. tolerance control or reporting intermediate results during event updates are candidates. For example:

typedef struct {
   meBoolean meToleranceControlled;
   meBoolean meIntermediateEventResults;
   meBoolean meModelStateCanBeSaved.
   ...
} meCapabilities;

An alternative is to store this information in the xml-file, and do not provide an additional function.


Migrated-From: https://trac.fmi-standard.org/ticket/13

Open-ness of intervals in 2.1 Mathematical Description

Reported by hansolsson on 7 Dec 2009 16:51 UTC
The description in 2.1 define that x(t) is a continuous function (and similar for other variables) inside each interval t_i < t < t_{i+1}.

I would change this to t_i <= t < t_{i+1}, i.e. the interval
[t_i, t_{i+1} ) with usual notation.

This also allows us to use the normal notation of filled circle at the right-end (to indicate that point is inside set) and unfilled circle at left-end (to indicate that point is not inside set).

Note that x(t_{i}) is already defined to be
lim x(t_{i}+eps) eps->0, i.e. it does not modify the behaviour - only the description.


Migrated-From: https://trac.fmi-standard.org/ticket/24

Improved initialization

Modified by dietmarw on 19 Mar 2012 09:26 UTC
The meInitialize function can currently only be called once for one instance. Therefore, iteration is not possible, i.e., an algebraic loop between connected FMUs can not be handled during initialization. This needs to be improved.

The best would be to mathematically define the initialization problem (probably difficult, due to logical unknowns) and the provide a function for this mathematical description form. Maybe, this is too much now and has to be shifted to the next version.


Reported by otter on 4 Dec 2009 08:20 UTC
The meInitialize function can currently only be called once for one instance. Therefore, iteration is not possible, i.e., an algebraic loop between connected FMUs can not be handled during initialization. This needs to be improved.

The best would be to mathematically define the initialization problem (probably difficult, due to logical unknowns) and the provide a function for this mathematical description form. Maybe, this is too much now and has to be shifted to the next version.


Migrated-From: https://trac.fmi-standard.org/ticket/14

Specification of Model Distribution (section 4) could be more detailed

Reported by torstenblochwitz on 6 Jan 2010 07:42 UTC
The following points of the model distribution structure are not 100 % clear for me:

  1. Some content is marked as optional and some (which could be optional too) are not. The following content could also be optional because it is possible to evaluate the model without it:
    model.png
    documentation
    sources
    binaries
    In the description below the structure we point out that at least one implementation must be given.
  2. The header files fmiModelTypes.h and fmiModelFunctions.h are located at several places in the structure. Do we really need them when we provide the fmu as binary? Using fmiGetModelTypesPlatform() and fmiGetVersion() should be sufficient to find out, if the standard files were used. The files have to be provided if the fmiGetModelTypesPlatform() does not return "standard32". If the files are provided they should be located in the sources folder only.

Migrated-From: https://trac.fmi-standard.org/ticket/32

Typos and minor corrections

Reported by mauss on 4 Jan 2010 11:19 UTC
section 1.1

  • cache computational results -> cache computed results
    section 2.2
    fmivalueReference -> fmiValueReference (several occurrences)
    fmiUndefinedvalueReference -> fmiUndefinedValueReference
    fmiGetStatevalueReferences -> fmiGetStateValueReferences,
    section 2.4
    fmiGetModelFunctionsVersion -> fmiGetVersion
    fmiModelFunctionsVersion -> fmiVersion
    section 2.8
    set comments green:
    // forward Euler method
    // compare sign of z with previous z
    section 3.1
    "structured: -> "structured":
    section 3.2, value reference
    replace
    This handle must not be unique.
    by
    This handle is not required to be unique.
    section 2.4
    fmiGetModelTypesPlatform();
    fmiGetModelFunctionsVersion();
    "The function returns a pointer to the static variable XXX
    defined in this header file."
    This is a macro now, not a static variable. Replace by
    "The function returns XXX which is defined in this header file."

Migrated-From: https://trac.fmi-standard.org/ticket/30

Real-time requirements: fmiEventUpdate

Reported by hassen on 5 May 2010 07:30 UTC
At IFP, we are working on optimisation of Modelica models (complex models)to obtain more performance for real-time simulations. Our goal is to decrease computation time to feet the real-time requirements. When finely examining the behavior of our models in Dymola, we noticed, that, in opposition to Simulink, precise event detection is performed even if a fixed step integrator is used. We believe that iterations occur in two situations :

1/ Event detection (zero crossing functions). It seems that within Dymola, a prediction event algorithm is used.("quick but less accurate", comment of Dymola support)
2/ Event propagation : Before a numerical solution of the differential equations is resumed, event propagation needs to be performed in order that all variables get consistent values. Dymola generates code for iterating the equations, called event iteration, until all Boolean mode variables have converged. This typically takes 1-3 extra evaluations of the equations, i.e. the calculation time to handle such an event might exceed the available time for the step.

This type of behavior (non deterministic) don't feet real-time requirements.

When generating C code from RTW with fixed step solver for Simulink models we noticed that it contains no zero crossing functions. Compared with the real time modelica code generated, it seems that zero crossing functions are implemented. We believe that eliminating these functions could increase performance greatly. This will have an impact on the accuracy of the simulation but it will feet our real-time requirements.

In this case, another function similar to the fmiEventUpdate() could be used for real time purposes. Disabling upcomingTimeEvent and nextEventTime could be a solution to force the simulation tool to neglect zero crossing functions and precise detection of events. In real-time FMUs, fmiEventUpdate should only tell the FMU to change behavior by changing its equations.

Best Regards,
Hassen


Migrated-From: https://trac.fmi-standard.org/ticket/38

fmiGetState/fmiSetState is more work than reject Steps

Modified by dietmarw on 19 Mar 2012 10:29 UTC
Rejecting last slave communication steps (indicated by the capability flag CanRejectSteps) can be handled using the new fmiGetState/fmiSetState functionality.
Otherwise slaves can be able to internally resetting the last communication step without being able to export the state via fmiGetState. Therefore, is seems to me useful to have to capability flags,
one for rejecting the last communication step (canRejectSteps),
and one for supporting the fmiGetState/fmiSetState functionality.

Are there other opinions?


Reported by clauss on 14 Apr 2011 13:03 UTC
Rejecting last slave communication steps (indicated by the capability flag CanRejectSteps) can be handled using the new fmiGetState/fmiSetState functionality.
Otherwise slaves can be able to internally resetting the last communication step without being able to export the state via fmiGetState. Therefore, is seems to me useful to have to capability flags,
one for rejecting the last communication step (canRejectSteps),
and one for supporting the fmiGetState/fmiSetState functionality.

Are there other opinions?


Migrated-From: https://trac.fmi-standard.org/ticket/52

XML encoding

Reported by andreas.junghanns on 25 Nov 2009 20:05 UTC
for the model description xml to contain letters outside 7-bit, (and to be proper per se) the first line of the XML file should indicate the encoding, e.g.

<?xml version="1.0" encoding="ISO-8859-1"?>

Rationale: The moment tools include manually added comments, these may contain special characters, like the German Umlauts.


Migrated-From: https://trac.fmi-standard.org/ticket/10

location of state events

Reported by mauss on 4 Oct 2009 13:50 UTC
We should state in section 2.1 (if correct) that

  • a zero of the event indicators with even multiplicity (as in z = t*t, zero only touched, not crossed) does not define a state event.
  • z(t) must be non-zero in the neighborhood of the event time, otherwise this is a model error.

Migrated-From: https://trac.fmi-standard.org/ticket/7

Discrete input

Reported by hansolsson on 7 Dec 2009 17:19 UTC
Assume that a variable is defined to be discrete Real/Integer input in the XML-file:

  • When can this variable be changed?
  • How is this co-ordinated with event iterations, alternatively: how does this influence discrete outputs?

Proposal:

Discrete inputs can only be changed after a step is completed.
Additional inputs can be changed after changing a discrete input; prior to continuing integration after changing any discrete input meEventUpdate should be called to handle any potential events in the model.

Note that the state machine in 2.8 must be updated as well.


Migrated-From: https://trac.fmi-standard.org/ticket/25

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.