1. CE 394K.2 Hydrology Introduction to OpenMI
Tim Whiteaker

2. What is OpenMI http://www.openmi.org/
The OpenMI standard defines an interface that allows time-dependent models to exchange data at runtime. When the standard is implemented, existing models can be run in parallel and share information at each time step.

3. Outline Background Thinking through integrated modeling
The OpenMI standard

4. Outline Background Thinking through integrated modeling
Who created OpenMI
Why did they create OpenMI
Thinking through integrated modeling
The OpenMI standard

5. History and Organization
Development team
14 organizations
7 countries
Funding
European Commission’s Fifth Framework programme
European Commission
Water Framework Directive
Fifth Framework programme
HarmonIT
OpenMI

6. European Commission (EC)
Executive body of EU
Proposes and implements legislation
One Commissioner from each member state
European Commission
Water Framework Directive
Fifth Framework programme
HarmonIT
OpenMI

7. Water Framework Directive (WFD)
Most substantial piece of EC water legislation to date
Enacted December 22, 2000
2015 – “good status” for inland and coastal waters
Defines standards and procedures
Requires whole catchment modeling
European Commission
Water Framework Directive
Fifth Framework programme
conditions of minimal anthropogenic impact
HarmonIT
OpenMI

8. Whole Catchment Modeling
Model interactions between hydrologic components
Rainfall/Runoff
Hydraulics
Groundwater
Ecology
Social
Key to integrated water management

9. Fifth Framework programme (FP5)
Prioritizes EU research, technological development and demonstration activities ( )
~15b euro for implementation
Programs
Quality of Life and management of living resources
User-friendly information society
Competitive and sustainable growth
Energy, environment and sustainable development
European Commission
Water Framework Directive
Fifth Framework programme
HarmonIT
OpenMI

10. HarmonIT
Supported by FP5’s Energy, environment and sustainable development program
Objective: to develop, implement and prove a system to simplify the linking of models to support whole catchment modeling
European Commission
Water Framework Directive
Fifth Framework programme
HarmonIT
OpenMI

11. HarmonIT Team Centre for Ecology and Hydrology
DHI Water and Environment
WL Delft Hydraulics
HR Wallingford Group
Institute for Inland Water Management and Waste Water Treatment RIZA
University of Dortmund
Instituto di Ricerca Sulle Acque (IRSA)
National Technical University of Athens
WRc plc
DHI Hydroinform a.s.
Povodi Labe s.p.
Hydroprojekt a.s.
Alterra B.V.
Centre National du Machinisme Agricole, du Genie Rural, des Eaux et des Forets
Team leader
Design and development
Management,
Support,
Testing

12. OpenMI Open Modeling Interface and Environment
Interface for model integration
Supports understanding and prediction of process interactions
European Commission
Water Framework Directive
Fifth Framework programme
HarmonIT
OpenMI

13. OpenMI Aims and Objectives
The aim of the OpenMI is to provide a mechanism by which physical and socioeconomic process models can be linked to each other, to other data sources and to a variety of tools at runtime, hence enabling process interactions to be better modeled.
Specific objectives are that the mechanism’s design should:
Be applicable to new and existing models
Impose as few restrictions as possible on the modeler’s freedom
Be applicable to most, if not all, time-based simulation techniques
Require the minimum of change to the program code of existing applications
Keep the cost, skill and time required to migrate an existing model to a minimum so that these factors are not a deterrent to the OpenMI’s use
Be easy to use
Not unreasonably degrade performance

14. Outline Background Thinking through integrated modeling
What is a model
How can models communicate
The OpenMI standard

15. What models do we have now
HMS - hydrologic
RAS – hydraulic – 1D, steady/unsteady
SWAT – Soil Water Assessment Tool
HSPF
BASINS (HSPF, QUAL2E)
MODFLOW
SWMM
EPA NET

16. What comprises a model

17. What does a model need to run
Separate Engine from User Interface
Set model parameters
Deal with Inputs and Outputs

18. Integrated Modeling ? How ? Application Application
Surface runoff
Evaporation
Precipitation
Application
Application
Rainfall/Runoff
Output data
Input data
User interface
User interface
Input data
Hydraulics ?
Rainfall runoff model
Output data
How ?
Estuary
Coast
Evaporation
River
Hydraulic model

19. Benefits of Integrated Modeling
Water Balance
Standardized, Modular system
Process interactions
Plug-and-play
Chance for individuals to publish models

20. How can models exchange data

21. Quantities are variables accepted or provided by a model
What
Quantities are variables accepted or provided by a model

22. Elements are the locations where quantities are measured

23. When
At each time step?
After simulations?
Iterations?

24. How
Model definition: Define quantities a model can exchange, and at which elements can it exchange them.
Configuration: Define which models are linked in terms of quantities and elements.
Runtime operation: Enable the model to accept or provide data at run time.

25. Outline Background Thinking through integrated modeling
The OpenMI standard

26. What is OpenMI: Revisted
The OpenMI standard defines an interface that allows time-dependent models to exchange data at runtime. When the standard is implemented, existing models can be run in parallel and share information at each time step.

27. What is an Interface result = Calculator.SquareRoot(16)
What’s the square root of 16?
Programs and functions, revisted
Program
Functions: 16
Math
library
Add
Multiply 4
SquareRoot

28. What is an Interface
An interface defines how a program interacts with an object
An interface includes properties and methods (functions)
Calculator
object
Math library
Functions:
Calculator
Math
library
Add
Multiply
Add (NumberArray) : Number
SquareRoot
Multiply (NumberArray) : Number
SquareRoot (Number) : Number

29. Interface for Hydro Data Exchange
Rainfall runoff
Get values
Hydraulic
Get values
Ecology
Get values
Economic
Get values
OpenMI defines an Interface
with a GetValues method, among others
Interface

30. OpenMI is ‘interface-based’
Its ‘standardized’ part is defined as a software interface specification.
This interface acts as a ‘contract’ between software components.
The interface is not limited to specific technology platforms or implementations.
By implementing this interface a component becomes an OpenMI compliant component.

31. OpenMI is ‘open’
Its specification is publicly available via the Internet (
It enables linkages between different kinds of models, different disciplines and different domains.
It offers a complete metadata structure to describe the numerical data that can be exchanged in terms of semantics, units, dimensions, spatial and temporal representation and data operations.
It provides a means to define exactly what is linked, how and when.
Its default implementation and software utilities are available under an open source software license.

32. OpenMI is a ‘standard’
It standardizes the way data transfer is specified and executed.
It allows any model to talk to any other model (e.g. from a different developer) without the need for cooperation between model developers or close communication between integrators and model developers.
Its generic nature does not limit itself to a specific domain in the water discipline or even in the environmental discipline.

33. GetValues Method Occurs at a time step Models called sequentially
For the geeks…
ILinkableComponent.GetValues(time :ITime, linkID :string) : IValueSet

34. GetValues Chaining Options
optimization and iteration controllers can be created for those operations

35. Handling GetValues

36. Conceptual Model for Data Exchange
GetValues(time, linkID)
when
what,where

37. Conceptual Model for Data Exchange
What the values represent and in what unit they are expressed is indicated by the quantity and its unit.
Where these values apply is indicated by the ElementSet class, which contains an ordered set of elements.
When the values apply is indicated by the time, either expressed as an instantaneous moment in time (a timestep) or a period over time (a time span).

38. Base units and base quantities in OpenMI (derived from SI)
Base quantity
SI base unit
Symbol used
Length
metre m
Mass
kilogram kg
Time
second s
ElectricCurrent
ampere A
Temperature
Kelvin K
AmountOfSubstance
mole
mol
LuminousIntensity
candela cd
Currency
Euro E

39. Example of ‘Quantities’

40. Elements (where exchange happens)
ID-based or geospatial representation
If geospatial, defined by set of nodes
May or may not be georeferenced
Elements in an ElementSet must be of the same type

41. Element Types

42. Examples of Element Sets

43. Element Set Properties

44. Interpreting positive values of fluxes, levels and depths

45. Data Operations
Operations which define how information is exchanged between exchange items
Spatial
Interpolation
TakeNearest
Temporal
Aggregation
Extrapolation
Other

46. Advanced Example
Data operations allow data to be exchanged between these two models at various types of interfaces (e.g., nodes, lines, interpolations on areas)

47. Exchange Items Grouping of Quantity and ElementSet
Input and Output exchange items
Output exchange items include DataOperation

48. Example of Exchange Items

49. Linkable Component
Model engine with implementation of OpenMI standard interface
DLL
Model Definition
Exchange Items
Configuration
Run-time operation
GetValues
Linkable Component
Rainfall-Runoff Model
--InputExchangeItems
--Quantities
--ElementSets
--OutputExchangeItems
Model

50. Links LINK Rainfall-Runoff Model River Model
A link is the data path connecting two linkable components
Linkable Component
Linkable Component
Rainfall-Runoff Model
--InputExchangeItems
--Quantities
--ElementSets
--OutputExchangeItems
River Model
--InputExchangeItems
--Quantities
--ElementSets
--OutputExchangeItems
LINK ID
Description
TargetComponent
TargetQuantity
TargetElementSet
SourceComponent
SourceQuantity
SourceElementSet
DataOperationsCount
GetDataOperation
Model
Model

51. Example Links

52. Composition LINK Composition Rainfall-Runoff Model River Model
A composition is a set of linkable components, possibly populated
with model data and interconnected with links.
Composition
Rainfall-Runoff Model
--InputExchangeItems
--Quantities
--ElementSets
--OutputExchangeItems
River Model
--InputExchangeItems
--Quantities
--ElementSets
--OutputExchangeItems
LINK
Model
Model

53. OpenMI Systems
An OpenMI system is any software application that includes a set of one or more OpenMI compliant components.
The system must know:
where it can find linkable components.
what links exist between linkable components.
how to instantiate, deploy and run a combination of linkable components.

54. OMI Files
An OMI file is an XML file that contains the information needed to instantiate an OpenMI component and populate it with input data.
An OMI file points to:
Location of DLL for the OpenMI compliant model
Location of input files

55. Deployment of an OpenMI linkable component
Instantiation and initialization. Read OMI file, construct linkable component, and populate with input data.
Inspection and configuration. Set up links with exchange items and validate links.
Preparation. Finish preparatory work before computation begins. For example, database and network connections are established, output files are opened and buffers are organized.
Computation/execution. Loop through each time step, making necessary calculations and exchanging data with other linkable components.
Completion. Close file and network connections, clean up memory, etc.
Disposal. This phase is entered when the application is closed. Remaining objects are removed and memory is deallocated.

56. OmiEd
A visual tool for building and running OpenMI systems

57. Steps to Building an OpenMI System
Start the configuration editor.
Add models to the composition.
Establish connections between the models.
Configure the connections.
Add a trigger.
Run the composition.

58. Migrating Existing Models
Rework engine to implement OpenMI interfaces
Allows exchange of quantities
Can be applied to databases or other data sources
Easiest way is to modify engine core and then wrap it

59. Requirements for OpenMI Linkable Components (1)
Initialization is separate from computation.
Available modeled quantities are exposed to the outside world.
Modeled quantities can be provided for any requested point in time and space.
The model must be able to respond to a request, even when the component itself is time independent; if the response requires data from another component, the component must be able to pass on the time in its own request.
The model must be able to submit to runtime control by an outside entity.

60. Requirements for OpenMI Linkable Components (2)
For components progressing in time, the requirement ‘always’ to return values when requested imposes the following conditions:
The delivering component must know what time it has reached, how that compares to the requested time, and how to proceed if the times don’t match up (extrapolate, compute, etc.).
Components must be able to interpolate if the requested time is not in their own time step or space frame.
Components must know when they are waiting for data, in which case they will have to return an extrapolated value.

61. Migrating a Model
OpenMI provides utilities to assist in migrating a model.
Model migration involves 7 steps.
Change the engine core.
Create the .NET assemblies.
Access the functions in the engine core.
Implement MyEngineDotNetAccess.
Implement the wrapper class.
Implement the linkable component.
Implement the remaining IEngine methods.

62. Model Migration: 1
Change the engine core. The model engine should be converted from an EXE file to a DLL, which can be accessed by other components.

63. Model Migration: 2
Create the .NET assemblies. After installing the OpenMI Environment, create assemblies for wrapper classes and test classes in the .NET development environment.

64. Model Migration: 3-7
Access the functions in the engine core. The engine needs to be accessible from .NET. The MyEngineDLLAccess class makes a one-to-one conversion of all exported functions in the engine core code to public .NET methods.
Implement MyEngineDotNetAccess. This class changes the calling conventions to C# conventions and converts error messages into .NET exceptions.
Implement the wrapper class. The MyEngineWrapper class implements the ILinkableEngine interface. (Initializing, Finalizing)
Implement the linkable component. The MyModelLinkableComponent class must be implemented. This class defines the linkable component that is accessed by other models.
Implement the remaining IEngine methods. The remaining methods in the MyEngineWrapper class must be implemented (e.g., GetValues). In some cases you may need to make changes to the engine core as well as adding code to the IEngine methods.

65. Acknowledgements Content and images are taken from material at