CE 394K.2 Hydrology Introduction to OpenMI

CE 394K.2 Hydrology

Introduction to OpenMI

Tim Whiteaker

What is OpenMI

• 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.

http://www.openmi.org/


Outline

• Background

• Thinking through integrated modeling

• The OpenMI standard

Outline

• Background– Who created OpenMI– Why did they create OpenMI



History and Organization

• Development team– 14 organizations– 7 countries

• Funding– European Commission’s

Fifth Framework programme

European Commission


HarmonIT

OpenMI

Water Framework Directive

European Commission (EC)

• Executive body of EU

• Proposes and implements legislation

• One Commissioner from each member state

• http://ec.europa.eu/

European Commission


HarmonIT

OpenMI


http://ec.europa.eu/index_en.htm



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• http://ec.europa.eu/environmen

t/water/water-framework/index_en.html

European Commission


HarmonIT

OpenMI


http://ec.europa.eu/environment/water/water-framework/index_en.html



Whole Catchment Modeling

• Model interactions between hydrologic components– Rainfall/Runoff– Hydraulics– Groundwater– Ecology– Social

• Key to integrated water management

Fifth Framework programme (FP5)

• Prioritizes EU research, technological development and demonstration activities (1998-2002)

• ~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• http://cordis.europa.eu/fp5/

European Commission


HarmonIT

OpenMI


http://cordis.europa.eu/fp5/

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

• http://www.harmonit.org/

European Commission


HarmonIT

OpenMI


http://www.harmonit.org/

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

OpenMI

• Open Modeling Interface and Environment

• Interface for model integration

• Supports understanding and prediction of process interactions

• http://www.openmi.org/

European Commission


HarmonIT

OpenMI





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

http://www.openmi.org/openminew/documents/A_OpenMI_Scope.pdf



Outline

• Background

• Thinking through integrated modeling– What is a model– How can models communicate


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

What comprises a model

What does a model need to run

• Separate Engine from User Interface

• Set model parameters

• Deal with Inputs and Outputs

Integrated Modeling

Rainfall/Runoff

Output data

Input data

User interface

Application

Hydraulics

Output data

Input data

User interface

Application

Surface runoff

Evaporation

Precipitation

Estuary

Coast

Evaporation

River

How ?

Rainfall runoff model

Hydraulic model

?

Benefits of Integrated Modeling

• Water Balance

• Standardized, Modular system

• Process interactions

• Plug-and-play

• Chance for individuals to publish models

How can models exchange data

What

Quantities are variables accepted or provided by a model

Where

Elements are the locations where quantities are

measured

When

At each time step?

After simulations?

Iterations?

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.

Outline

• Background



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.



What is an Interface

Program

Mathlibrary

Add

Multiply

SquareRoot

Functions:

What’s the square root

of 16?

16

4

result = Calculator.SquareRoot(16)

Programs and functions, revisted

What is an Interface

• An interface defines how a program interacts with an object

• An interface includes properties and methods (functions)

Math library

Calculator

Add (NumberArray) : Number

Multiply (NumberArray) : Number

SquareRoot (Number) : Number

Mathlibrary

Add

Multiply

SquareRoot

Functions:

Calculatorobject

Interface for Hydro Data Exchange

Rainfall runoffGet values

HydraulicGet values

EcologyGet values

EconomicGet values

OpenMI defines an Interface with a GetValues method, among others

Interface

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.

OpenMI is ‘open’• Its specification is publicly available via the Internet (

www.OpenMI.org).

• 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.


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.

GetValues Method

• Occurs at a time step

• Models called sequentially

• For the geeks…ILinkableComponent.GetValues(time :ITime, linkID :string) : IValueSet

GetValues Chaining Options

Handling GetValues

Conceptual Model for Data Exchange

GetValues(time, linkID)

when what,where

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).

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

Example of ‘Quantities’

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

Element Types

Examples of Element Sets

Element Set Properties

Interpreting positive values of fluxes, levels and depths

Data Operations

• Operations which define how information is exchanged between exchange items

• Spatial– Interpolation– TakeNearest

• Temporal– Aggregation– Extrapolation

• Other

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)

Exchange Items

• Grouping of Quantity and ElementSet

• Input and Output exchange items

• Output exchange items include DataOperation

Example of Exchange Items

Linkable Component

• Model engine with implementation of OpenMI standard interface– DLL– Model Definition

• Exchange Items

– Configuration– Run-time operation

• GetValues

Rainfall-Runoff Model --InputExchangeItems --Quantities --ElementSets --OutputExchangeItems --Quantities --ElementSets

Model

Linkable Component

Links


River Model --InputExchangeItems --Quantities --ElementSets --OutputExchangeItems --Quantities --ElementSets

LINK

IDDescription

TargetComponentTargetQuantity

TargetElementSetSourceComponent

SourceQuantitySourceElementSet

DataOperationsCountGetDataOperation

A link is the data path connecting two linkable components

Model Model

Linkable Component Linkable Component

Example Links

Composition


River Model --InputExchangeItems --Quantities --ElementSets --OutputExchangeItems --Quantities --ElementSets

LINK

A composition is a set of linkable components, possibly populatedwith model data and interconnected with links.

Model Model

Composition

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.

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

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.

OmiEdA visual tool for building and running OpenMI systems

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.

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

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.

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.

Migrating a Model

• OpenMI provides utilities to assist in migrating a model.

• Model migration involves 7 steps.

1. Change the engine core. 2. Create the .NET assemblies. 3. Access the functions in the engine core. 4. Implement MyEngineDotNetAccess. 5. Implement the wrapper class. 6. Implement the linkable component. 7. Implement the remaining IEngine methods.

Model Migration: 11. Change the engine core. The model engine should be converted from

an EXE file to a DLL, which can be accessed by other components.

Model Migration: 22. Create the .NET assemblies. After installing the OpenMI Environment,

create assemblies for wrapper classes and test classes in the .NET development environment.

Model Migration: 3-73. 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.

4. Implement MyEngineDotNetAccess. This class changes the calling conventions to C# conventions and converts error messages into .NET exceptions.

5. Implement the wrapper class. The MyEngineWrapper class implements the ILinkableEngine interface. (Initializing, Finalizing)

6. Implement the linkable component. The MyModelLinkableComponent class must be implemented. This class defines the linkable component that is accessed by other models.

7. 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.

Acknowledgements

• Content and images are taken from material at – http://www.openmi.org/openminew/– http://www.openmi-life.org/

http://www.openmi.org/openminew/

http://www.openmi-life.org/

CE 394K.2 Hydrology Introduction to OpenMI

Documents

Transcript of CE 394K.2 Hydrology Introduction to OpenMI