See also: OATC Wiki Home

Date: June 25, 2010
Time: 10:00 - 11:30 am
Venue: Skype Conference Call
Topic: Extendable version of OpenMI 2 (continued)

Table of contents

Participants

Rob Knapen, Alterra, Wageningen UR (Rob.Knapen@wur.nl)
Standa Vanecek, DHI (s.vanecek@dhi.cz)
Adrian Harper, Wallingford Software (adrian.harper@wallingfordsoftware.com)
Stef Hummel, Deltares (stef.hummel@deltares.nl)
~don, Deltares (gennadii.donchyts@deltares.nl)
Jesper Grooss, DHI (jgr@dhigroup.com)
Peter Schade, Bundesanstalt fuer Wasserbau (peter.schade(at)baw.de)

1. Progress towards OpenMI 2 Beta release

1.1. Source code updates

The trunk has been tagged as /svnroot/openmi/tags/OpenMI-2.0.0-20100618-BeforeExtendable, before any of the extendable changes have been applied.

The OpenMI-2.0.0-extendable branch has been merged into the trunk. This means that the OpenMI-2.0.0-extendable branch should no longer be used (and eventually deleted).

1.2. Documentation updates

2. Ongoing discussion topics

2.1. Note about OpenMI 2 compliancy

(Peter) To be decided: which compliancy is more appropriate?

(Rob) I prefer the second option. However besides stating when something is compliant, I think we should also make it more clear what this means in practice for the average modeler / user.

(Jesper) I would also vote for the second option. Though maybe rephrasing:

2. An OpenMI compliant component can also comply to one ore more extensions, by implementing the IBaseLinkableComponent interface and the extension interfaces which it wishes to comply to, according to the specifications provided as comments in the OpenMI.Standard2 source code.

2.1.1. Slightly changed from 1.4 compliancy

The IBaseLinkableComponent is the key interface in the OpenMI standard version 2. Any OpenMI compliant component must implement IBaseLinkableComponent.
OpenMI-compliance definition:

1. An OpenMI-compliant component must implement the IBaseLinkableComponent interface according to specifications provided as comments in the OpenMI.Standard2 interface source code. *
2. An OpenMI-compliant component must, when compiled, reference the OpenMI.Standard2.dll, which is released and compiled by the OpenMI Association.
3. An OpenMI-compliant component must be associated with an XML file, which complies to (can be validated with) the BaseLinkableComponent.xsd schema (same information a 4. - leave it out?)
4. An OpenMI-compliant component must be associated with an XML file, which complies to (can be validated with) the OpenMICompliancyInfo.xsd schema. This file must be submitted to the OpenMI Association.
5. The OpenMI Association provides two additional interfaces that OpenMI-compliant components may or may not implement: the IManageState interface and the IByteStateConverter interface. However, if these interfaces are implemented, each method and property must be implemented according to the comments given in the OpenMI.Standard2 interface source code.
6. The OpenMI Association's downloadable standard zip file provides the only recognized version of source files, XML schemas and assembly files.

* at 1. The OpenMI Association provides extensions to the standard with more specific interfaces, e.g. for time and space dependent components. Although these extensions are part of the standard they are formally not required for compliancy. But the OpenMI Association recommends to implement the appropriate extension for easier data exchange with other OpenMI compliant components.
This means a change in the implementation of the classical time and space dependent component, which had in 1.x  just to implement the basic ILinkableComponent. For OpenMI 2 compliancy this component would have to implement the basic and the time and space specific extension interfaces.

2.1.2. Two level compliancy

The compliancy with the OpenMI 2 standard is split into two levels. The OpenMI compliancy on the first level refers to basic interfaces whereas the OpenMI extension-compliancy includes additional interfaces, e.g. for time and space dependent components.

The IBaseLinkableComponent is the key interface in the OpenMI standard version 2.

OpenMI-compliance definition:

1. An OpenMI-compliant component must implement the IBaseLinkableComponent interface according to the specifications provided as comments in the OpenMI.Standard2 interface source code.
2. An OpenMI extension-compliant component must implement the IBaseLinkableComponent interface and at least one of the extension interfaces according to the specifications provided as comments in the OpenMI.Standard2 interface source code. *
3. An OpenMI-compliant as well as an OpenMI extension-compliant component must, when compiled, reference the OpenMI.Standard2.dll, which is released and compiled by the OpenMI Association.
4. An OpenMI-compliant as well as an OpenMI extension-compliant component must be associated with an XML file, which complies to (can be validated with) the OpenMICompliancyInfo.xsd schema. This file must be submitted to the OpenMI Association.
5. The OpenMI Association provides two additional interfaces that OpenMI-compliant components may or may not implement: the IManageState interface and the IByteStateConverter interface. However, if these interfaces are implemented, each method and property must be implemented according to the comments given in the OpenMI.Standard2 interface source code.
6. The OpenMI Association's downloadable standard zip file provides the only recognized version of source files, XML schemas and assembly files.

* at 2.: This leads to a main difference between OpenMI 1.x and OpenMI 2. In order to become 1.x compliant the classical time and space dependent component just had to implement the basic ILinkableComponent. This component would have to implement the basic and the time and space specific extension interfaces for becoming OpenMI 2 compliant.

2.1.3. What does the compliancy definition mean for the user?

Linking OpenMI 2 compliant components has become much more flexible than it used to be with OpenMI 1.x. Components with different concepts or in OpenMI language extensions can exchange their data. A component with the classical Modified Julian Day time definition can for example provide a consumer component, defining its simulation time by an index, with data. The provider would implement the time and space extension whereas the consumer could implement an extension for index-related dictionaries. The provider should contain an AdaptedOutput converter using both time definitions and thus being able to convert the time to the index value. More knowledge about the underlying extensions is required from the user in order to select the appropriate items and to check the plausibility of the results. This is the price being paid for higher flexibility, less due to the OpenMI but to the complexity of the task.
If both LinkableComponents implement the same OpenMI extension interface, their provider consumer relationship will remain as straight forward as with OpenMI 1.x, the conversions in AdaptedOutput will be easier to use.

When writing this documentation in Summer 2010, only the base interfaces and an extension for the classical time and space dependent components are available. Future extensions could support parallel computing, compliancy with the standards of the Open Geospatial Consortium OGC and much more.

One should remember that compliancy does not mean a pure plug and play connection. From the technical point of view most of the input and output of two LinkableComponents can be connected for data exchange. But neither the standard nor the related sdk offer too much methods for checking the correctness of the selected variables. The user has the responsibility for selecting the appropriate quantities and the locations where they are defined. The approved, but updated interface definitions as well as the extensions preserve the slimness of the OpenMI.

2.1.4. What does the compliancy definition mean for an application developer?

todo, after 2.2. has been decided

2.2. How to define the extension interfaces

(Rob) Still considering the two approaches: using a hierarchy (i.e. ITimeSpaceLinkableComponent extends IBaseLinkableComponent, MyComponent implements ITimeSpaceLinkableComponent) or composition (i.e. MyComponent implements ILinkableComponent, ILinkableComponentTimeSpaceExtension). Should consider the effect when adding a linkable component interface for the loop method(s) or for the FRAMES dictionary support. Also see how OGC spatial element sets can be added as an extension and how this effects the interfaces.

(Jesper) I have added a third alternative, which is somewhat in between. The more I look at it, the more I prefer alternative 2.

(Peter) The second alternative has the advantage that a developer sees clearer what is implemented in e.g. MyParallelTimeSpaceComponent. Alternative 1 and 3 mean that he has to know or to look up that IBaseLinkableComponent is included. (Shouldn't it be IBaseLinkableComponent in the first line of alt. 2?)
On the other hand, if an extension has a problem with a method of ILinkableComponent which is not part of the extension, will it be allowed to overwrite it? In this case the second alternative would mean two different versions of the method, the original one and the overwritten one.

Alternative 1 (interface hierarchy):

IBaseLinkableComponent { base methods };
ITimeSpaceLinkableComponent extends IBaseLinkableComponent { time-space methods };
IParallelTimeSpaceLinkableComponent extends ITimeSpaceLinkableComponent { loop methods };

IDictionaryLinkableComponent extends IBaseLinkableComponent { dictionary methods };
IParallelDictionaryLinkableComponent extends IDictionaryLinkableComponent { loop methods };

MyParallelTimeSpaceComponent implements IParallelTimeSpaceLinkableComponent {};
MyParallelDictionaryComponent implements IParallelDictionaryLinkableComponent {};

Alternative 2 (uncoupled interfaces):

ILinkableComponent { base methods };
ILinkableComponentTimeSpaceExtension { time-space methods };
ILinkableComponentParallelExtension { loop methods };
ILinkableComponentDictionaryExtension { dictionary methods };

MyParallelTimeSpaceComponent implements ILinkableComponent, ILinkableComponentTimeSpaceExtension, ILinkableComponentParallelExtension {};
MyParallelDictionaryComponent implements ILinkableComponent, ILinkableComponentDictionaryExtension, ILinkableComponentParallelExtension {};

Alternative 3 (in between):

IBaseLinkableComponent { base methods };
ITimeSpaceLinkableComponent extends IBaseLinkableComponent { time-space methods };
IParallelLinkableComponent extends IBaseLinkableComponent { loop methods };
IDictionaryLinkableComponent extends IBaseLinkableComponent { dictionary methods };

MyParallelTimeSpaceComponent implements ITimeSpaceLinkableComponent, IParallelLinkableComponent {};
MyParallelDictionaryComponent implements IDictionaryLinkableComponent, IParallelLinkableComponent {};

3. New discussion topics

3.1. How to package and distribute extensions

(Rob) When an extension is approved by OATC will it be included into the Standard library (dll or jar), or will each extension be distributed in its own library?

(Peter) To keep it in the standard library will make the check on compliancy easier, s. 2.1.2. saying compliant models have to reference OpenMI2.Standard.dll/jar. One argument pro an own library is that new extensions can be more frequently updated than the standard. Anyway, I guess the OAEC has to decide formally about new extensions as it did about compliancy of models in the past.

(Jesper) I believe (at least for C#, I am not sure with java) when we first have released the OpenMI2.Standard.dll, then there are issues in case this dll is updated to include e.g. a dictionary extension: Two different OpenMI2.Standard.dll files having the same version number, but different content. It would be much more safe to release an OpenMI2.Standard.DictionaryExtension.dll, and leaving the original content in the OpenMI.Standard.dll. It may be possible to put it all in a new standard dll, however that requires "intelligent" installers: Assume I am to install a TimeSpace engine and a Dictionary engine, which come with each their version of the OpenMI2.Standard.dll that they want to install and register in the GAC. Depending on the order in which I install the engines, each installer needs to know whether they are to reregister their version of the OpenMI2.Standard.dll in the GAC, to assure that the newest version is the one registered.